io.vertx.rxjava.core.http

## Class HttpClient

- java.lang.Object
- - io.vertx.rxjava.core.http.HttpClient

- All Implemented Interfaces:
    Measured

      public class HttpClient
      extends Object
      implements Measured

  An asynchronous HTTP client.

  It allows you to make requests to HTTP servers, and a single client can make requests to any server.

  It also allows you to open WebSockets to servers.

  The client can also pool HTTP connections.

  For pooling to occur, keep-alive must be true on the `HttpClientOptions` (default is true). In this case connections will be pooled and re-used if there are pending HTTP requests waiting to get a connection, otherwise they will be closed.

  This gives the benefits of keep alive when the client is loaded but means we don't keep connections hanging around unnecessarily when there would be no benefits anyway.

  The client also supports pipe-lining of requests. Pipe-lining means another request is sent on the same connection before the response from the preceding one has returned. Pipe-lining is not appropriate for all requests.

  To enable pipe-lining, it must be enabled on the `HttpClientOptions` (default is false).

  When pipe-lining is enabled the connection will be automatically closed when all in-flight responses have returned and there are no outstanding pending requests to write.

  The client is designed to be reused between requests.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<HttpClient>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `HttpClient(HttpClient delegate)`
    `HttpClient(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Close the client.
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client.
    `HttpClient` | `connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `void` | `delete(int port, String host, String requestURI)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `delete(int port, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `delete(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `delete(int port, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `delete(RequestOptions options)` Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `delete(RequestOptions options, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `delete(String requestURI)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `delete(String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `delete(String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `delete(String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `delete(String host, String requestURI)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `delete(String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `delete(String host, String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `delete(String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `boolean` | `equals(Object o)`
    `void` | `get(int port, String host, String requestURI)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `get(int port, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `get(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `get(int port, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `get(RequestOptions options)` Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
    `void` | `get(RequestOptions options, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
    `void` | `get(String requestURI)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `get(String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `get(String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `get(String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `get(String host, String requestURI)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `get(String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `get(String host, String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `get(String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClient` | `getDelegate()`
    `int` | `hashCode()`
    `void` | `head(int port, String host, String requestURI)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `head(int port, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `head(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `head(int port, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `head(RequestOptions options)` Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
    `void` | `head(RequestOptions options, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
    `void` | `head(String requestURI)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `head(String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `head(String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `head(String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `void` | `head(String host, String requestURI)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `head(String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `head(String host, String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `head(String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `boolean` | `isMetricsEnabled()` Whether the metrics are enabled for this measured object
    `static HttpClient` | `newInstance(HttpClient arg)`
    `void` | `options(int port, String host, String requestURI)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `options(int port, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `options(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `options(int port, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `options(RequestOptions options)` Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `options(RequestOptions options, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `options(String requestURI)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `options(String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `options(String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `options(String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `options(String host, String requestURI)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `options(String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `options(String host, String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `options(String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, Buffer body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, Observable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `post(String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `post(String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, Buffer body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `put(String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `put(String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClient` | `redirectHandler(java.util.function.Function<HttpClientResponse,Future<RequestOptions>> handler)` Set a redirect handler for the http client.
    `void` | `request(HttpMethod method, int port, String host, String requestURI)` Create an HTTP request to send to the server at the `host` and `port`.
    `void` | `request(HttpMethod method, int port, String host, String requestURI, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server at the `host` and `port`.
    `void` | `request(HttpMethod method, String requestURI)` Create an HTTP request to send to the server at the default host and port.
    `void` | `request(HttpMethod method, String requestURI, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server at the default host and port.
    `void` | `request(HttpMethod method, String host, String requestURI)` Create an HTTP request to send to the server at the `host` and default port.
    `void` | `request(HttpMethod method, String host, String requestURI, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server at the `host` and default port.
    `void` | `request(RequestOptions options)` Create an HTTP request to send to the server.
    `void` | `request(RequestOptions options, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server.
    `Single<Void>` | `rxClose()` Close the client.
    `Single<HttpClientResponse>` | `rxDelete(int port, String host, String requestURI)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(RequestOptions options)` Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(String requestURI)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(String host, String requestURI)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxDelete(String host, String requestURI, MultiMap headers)` Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(int port, String host, String requestURI)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(RequestOptions options)` Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(String requestURI)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(String host, String requestURI)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxGet(String host, String requestURI, MultiMap headers)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(int port, String host, String requestURI)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(RequestOptions options)` Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(String requestURI)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(String host, String requestURI)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxHead(String host, String requestURI, MultiMap headers)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(int port, String host, String requestURI)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(int port, String host, String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(RequestOptions options)` Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(String requestURI)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(String host, String requestURI)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxOptions(String host, String requestURI, MultiMap headers)` Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(RequestOptions options, Buffer body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(RequestOptions options, Observable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPost(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(RequestOptions options, Buffer body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(RequestOptions options, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxPut(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientRequest>` | `rxRequest(HttpMethod method, int port, String host, String requestURI)` Create an HTTP request to send to the server at the `host` and `port`.
    `Single<HttpClientRequest>` | `rxRequest(HttpMethod method, String requestURI)` Create an HTTP request to send to the server at the default host and port.
    `Single<HttpClientRequest>` | `rxRequest(HttpMethod method, String host, String requestURI)` Create an HTTP request to send to the server at the `host` and default port.
    `Single<HttpClientRequest>` | `rxRequest(RequestOptions options)` Create an HTTP request to send to the server.
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(RequestOptions options)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(RequestOptions options, Buffer body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(RequestOptions options, Observable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | `rxSend(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<WebSocket>` | `rxWebSocket(int port, String host, String requestURI)` Connect a WebSocket to the specified port, host and relative request URI
    `Single<WebSocket>` | `rxWebSocket(String requestURI)` Connect a WebSocket at the relative request URI using the default host and port
    `Single<WebSocket>` | `rxWebSocket(String host, String requestURI)` Connect a WebSocket to the host and relative request URI and default port
    `Single<WebSocket>` | `rxWebSocket(WebSocketConnectOptions options)` Connect a WebSocket with the specified options.
    `Single<WebSocket>` | `rxWebSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
    `void` | `send(HttpMethod method, int port, String host, String requestURI)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | `send(RequestOptions options)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, Buffer body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, Observable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | `send(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `String` | `toString()`
    `void` | `webSocket(int port, String host, String requestURI)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | `webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | `webSocket(String requestURI)` Connect a WebSocket at the relative request URI using the default host and port
    `void` | `webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket at the relative request URI using the default host and port
    `void` | `webSocket(String host, String requestURI)` Connect a WebSocket to the host and relative request URI and default port
    `void` | `webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the host and relative request URI and default port
    `void` | `webSocket(WebSocketConnectOptions options)` Connect a WebSocket with the specified options.
    `void` | `webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | `webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
    `void` | `webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface io.vertx.rxjava.core.metrics.Measured

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<HttpClient> __TYPE_ARG

  - ### Constructor Detail

    - #### HttpClient

          public HttpClient(HttpClient delegate)

    - #### HttpClient

          public HttpClient(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public HttpClient getDelegate()

      Specified by:
        `getDelegate` in interface `Measured`

    - #### isMetricsEnabled

          public boolean isMetricsEnabled()

      Whether the metrics are enabled for this measured object
      Specified by:
        `isMetricsEnabled` in interface `Measured`
      Returns:
        `true` if metrics are enabled

    - #### send

          public void send(RequestOptions options,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler

    - #### send

          public void send(RequestOptions options)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options

    - #### rxSend

          public Single<HttpClientResponse> rxSend(RequestOptions options)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
      Returns:

    - #### send

          public void send(RequestOptions options,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(RequestOptions options,
                           Buffer body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(RequestOptions options,
                                                   Buffer body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### send

          public void send(RequestOptions options,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(RequestOptions options,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(RequestOptions options,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### send

          public void send(RequestOptions options,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(RequestOptions options,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(RequestOptions options,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           Buffer body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           int port,
                           String host,
                           String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   int port,
                                                   String host,
                                                   String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           Buffer body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String host,
                           String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String host,
                                                   String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   MultiMap headers)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           Buffer body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   Buffer body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### send

          public void send(HttpMethod method,
                           String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxSend

          public Single<HttpClientResponse> rxSend(HttpMethod method,
                                                   String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### request

          public void request(RequestOptions options,
                              Handler<AsyncResult<HttpClientRequest>> handler)

      Create an HTTP request to send to the server. The `handler` is called when the request is ready to be sent.
      Parameters:
        `options` - the request options
        `handler` - the handler called when the request is ready to be sent

    - #### request

          public void request(RequestOptions options)

      Create an HTTP request to send to the server. The `handler` is called when the request is ready to be sent.
      Parameters:
        `options` - the request options

    - #### rxRequest

          public Single<HttpClientRequest> rxRequest(RequestOptions options)

      Create an HTTP request to send to the server. The `handler` is called when the request is ready to be sent.
      Parameters:
        `options` - the request options
      Returns:

    - #### request

          public void request(HttpMethod method,
                              int port,
                              String host,
                              String requestURI,
                              Handler<AsyncResult<HttpClientRequest>> handler)

      Create an HTTP request to send to the server at the `host` and `port`. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `handler` - the handler called when the request is ready to be sent

    - #### request

          public void request(HttpMethod method,
                              int port,
                              String host,
                              String requestURI)

      Create an HTTP request to send to the server at the `host` and `port`. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxRequest

          public Single<HttpClientRequest> rxRequest(HttpMethod method,
                                                     int port,
                                                     String host,
                                                     String requestURI)

      Create an HTTP request to send to the server at the `host` and `port`. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### request

          public void request(HttpMethod method,
                              String host,
                              String requestURI,
                              Handler<AsyncResult<HttpClientRequest>> handler)

      Create an HTTP request to send to the server at the `host` and default port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `handler` - the handler called when the request is ready to be sent

    - #### request

          public void request(HttpMethod method,
                              String host,
                              String requestURI)

      Create an HTTP request to send to the server at the `host` and default port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI

    - #### rxRequest

          public Single<HttpClientRequest> rxRequest(HttpMethod method,
                                                     String host,
                                                     String requestURI)

      Create an HTTP request to send to the server at the `host` and default port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### request

          public void request(HttpMethod method,
                              String requestURI,
                              Handler<AsyncResult<HttpClientRequest>> handler)

      Create an HTTP request to send to the server at the default host and port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `handler` - the handler called when the request is ready to be sent

    - #### request

          public void request(HttpMethod method,
                              String requestURI)

      Create an HTTP request to send to the server at the default host and port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI

    - #### rxRequest

          public Single<HttpClientRequest> rxRequest(HttpMethod method,
                                                     String requestURI)

      Create an HTTP request to send to the server at the default host and port. The `handler` is called when the request is ready to be sent.
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
      Returns:

    - #### get

          public void get(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### get

          public void get(int port,
                          String host,
                          String requestURI,
                          MultiMap headers)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxGet

          public Single<HttpClientResponse> rxGet(int port,
                                                  String host,
                                                  String requestURI,
                                                  MultiMap headers)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### get

          public void get(String host,
                          String requestURI,
                          MultiMap headers,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### get

          public void get(String host,
                          String requestURI,
                          MultiMap headers)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxGet

          public Single<HttpClientResponse> rxGet(String host,
                                                  String requestURI,
                                                  MultiMap headers)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### get

          public void get(String requestURI,
                          MultiMap headers,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### get

          public void get(String requestURI,
                          MultiMap headers)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxGet

          public Single<HttpClientResponse> rxGet(String requestURI,
                                                  MultiMap headers)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### get

          public void get(RequestOptions options,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler

    - #### get

          public void get(RequestOptions options)

      Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options

    - #### rxGet

          public Single<HttpClientResponse> rxGet(RequestOptions options)

      Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
      Returns:

    - #### get

          public void get(int port,
                          String host,
                          String requestURI,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### get

          public void get(int port,
                          String host,
                          String requestURI)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxGet

          public Single<HttpClientResponse> rxGet(int port,
                                                  String host,
                                                  String requestURI)

      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### get

          public void get(String host,
                          String requestURI,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### get

          public void get(String host,
                          String requestURI)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI

    - #### rxGet

          public Single<HttpClientResponse> rxGet(String host,
                                                  String requestURI)

      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### get

          public void get(String requestURI,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### get

          public void get(String requestURI)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI

    - #### rxGet

          public Single<HttpClientResponse> rxGet(String requestURI)

      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   MultiMap headers,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   MultiMap headers,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           MultiMap headers,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   MultiMap headers,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### post

          public void post(RequestOptions options,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(RequestOptions options,
                           Buffer body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(RequestOptions options,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### post

          public void post(RequestOptions options,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(RequestOptions options,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(RequestOptions options,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### post

          public void post(RequestOptions options,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(RequestOptions options,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(RequestOptions options,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(int port,
                           String host,
                           String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(int port,
                                                   String host,
                                                   String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String host,
                           String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String host,
                           String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String host,
                                                   String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           Buffer body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           Buffer body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   Buffer body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           ReadStream<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   ReadStream<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### post

          public void post(String requestURI,
                           Observable<Buffer> body,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### post

          public void post(String requestURI,
                           Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPost

          public Single<HttpClientResponse> rxPost(String requestURI,
                                                   Observable<Buffer> body)

      Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  MultiMap headers,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  MultiMap headers,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  MultiMap headers,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          MultiMap headers,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  MultiMap headers,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `body` - the request body
      Returns:

    - #### put

          public void put(RequestOptions options,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(RequestOptions options,
                          Buffer body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(RequestOptions options,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### put

          public void put(RequestOptions options,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(RequestOptions options,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(RequestOptions options,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### put

          public void put(RequestOptions options,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(RequestOptions options,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(RequestOptions options,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(int port,
                          String host,
                          String requestURI,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(int port,
                                                  String host,
                                                  String requestURI,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String host,
                          String requestURI,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String host,
                          String requestURI,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String host,
                                                  String requestURI,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          Buffer body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          Buffer body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  Buffer body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          ReadStream<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  ReadStream<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### put

          public void put(String requestURI,
                          Observable<Buffer> body,
                          Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
        `responseHandler` - the response handler

    - #### put

          public void put(String requestURI,
                          Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body

    - #### rxPut

          public Single<HttpClientResponse> rxPut(String requestURI,
                                                  Observable<Buffer> body)

      Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `body` - the request body
      Returns:

    - #### head

          public void head(int port,
                           String host,
                           String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### head

          public void head(int port,
                           String host,
                           String requestURI,
                           MultiMap headers)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxHead

          public Single<HttpClientResponse> rxHead(int port,
                                                   String host,
                                                   String requestURI,
                                                   MultiMap headers)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### head

          public void head(String host,
                           String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### head

          public void head(String host,
                           String requestURI,
                           MultiMap headers)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxHead

          public Single<HttpClientResponse> rxHead(String host,
                                                   String requestURI,
                                                   MultiMap headers)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### head

          public void head(String requestURI,
                           MultiMap headers,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### head

          public void head(String requestURI,
                           MultiMap headers)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxHead

          public Single<HttpClientResponse> rxHead(String requestURI,
                                                   MultiMap headers)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### head

          public void head(RequestOptions options,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler

    - #### head

          public void head(RequestOptions options)

      Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options

    - #### rxHead

          public Single<HttpClientResponse> rxHead(RequestOptions options)

      Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
      Returns:

    - #### head

          public void head(int port,
                           String host,
                           String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### head

          public void head(int port,
                           String host,
                           String requestURI)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxHead

          public Single<HttpClientResponse> rxHead(int port,
                                                   String host,
                                                   String requestURI)

      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### head

          public void head(String host,
                           String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### head

          public void head(String host,
                           String requestURI)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI

    - #### rxHead

          public Single<HttpClientResponse> rxHead(String host,
                                                   String requestURI)

      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### head

          public void head(String requestURI,
                           Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### head

          public void head(String requestURI)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI

    - #### rxHead

          public Single<HttpClientResponse> rxHead(String requestURI)

      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
      Returns:

    - #### options

          public void options(int port,
                              String host,
                              String requestURI,
                              MultiMap headers,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### options

          public void options(int port,
                              String host,
                              String requestURI,
                              MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(int port,
                                                      String host,
                                                      String requestURI,
                                                      MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### options

          public void options(String host,
                              String requestURI,
                              MultiMap headers,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### options

          public void options(String host,
                              String requestURI,
                              MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(String host,
                                                      String requestURI,
                                                      MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### options

          public void options(String requestURI,
                              MultiMap headers,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### options

          public void options(String requestURI,
                              MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(String requestURI,
                                                      MultiMap headers)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### options

          public void options(RequestOptions options,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler

    - #### options

          public void options(RequestOptions options)

      Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(RequestOptions options)

      Sends an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
      Returns:

    - #### options

          public void options(int port,
                              String host,
                              String requestURI,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### options

          public void options(int port,
                              String host,
                              String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(int port,
                                                      String host,
                                                      String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### options

          public void options(String host,
                              String requestURI,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### options

          public void options(String host,
                              String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(String host,
                                                      String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### options

          public void options(String requestURI,
                              Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### options

          public void options(String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI

    - #### rxOptions

          public Single<HttpClientResponse> rxOptions(String requestURI)

      Sends an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
      Returns:

    - #### delete

          public void delete(int port,
                             String host,
                             String requestURI,
                             MultiMap headers,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### delete

          public void delete(int port,
                             String host,
                             String requestURI,
                             MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(int port,
                                                     String host,
                                                     String requestURI,
                                                     MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### delete

          public void delete(String host,
                             String requestURI,
                             MultiMap headers,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### delete

          public void delete(String host,
                             String requestURI,
                             MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(String host,
                                                     String requestURI,
                                                     MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### delete

          public void delete(String requestURI,
                             MultiMap headers,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `responseHandler` - the response handler

    - #### delete

          public void delete(String requestURI,
                             MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(String requestURI,
                                                     MultiMap headers)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:

    - #### delete

          public void delete(RequestOptions options,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler

    - #### delete

          public void delete(RequestOptions options)

      Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(RequestOptions options)

      Sends an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
      Returns:

    - #### delete

          public void delete(int port,
                             String host,
                             String requestURI,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### delete

          public void delete(int port,
                             String host,
                             String requestURI)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(int port,
                                                     String host,
                                                     String requestURI)

      Sends an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### delete

          public void delete(String host,
                             String requestURI,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### delete

          public void delete(String host,
                             String requestURI)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(String host,
                                                     String requestURI)

      Sends an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### delete

          public void delete(String requestURI,
                             Handler<AsyncResult<HttpClientResponse>> responseHandler)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler

    - #### delete

          public void delete(String requestURI)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI

    - #### rxDelete

          public Single<HttpClientResponse> rxDelete(String requestURI)

      Sends an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
      Returns:

    - #### webSocket

          public void webSocket(int port,
                                String host,
                                String requestURI,
                                Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          public void webSocket(int port,
                                String host,
                                String requestURI)

      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI

    - #### rxWebSocket

          public Single<WebSocket> rxWebSocket(int port,
                                               String host,
                                               String requestURI)

      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### webSocket

          public void webSocket(String host,
                                String requestURI,
                                Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          public void webSocket(String host,
                                String requestURI)

      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI

    - #### rxWebSocket

          public Single<WebSocket> rxWebSocket(String host,
                                               String requestURI)

      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:

    - #### webSocket

          public void webSocket(String requestURI,
                                Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          public void webSocket(String requestURI)

      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI

    - #### rxWebSocket

          public Single<WebSocket> rxWebSocket(String requestURI)

      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI
      Returns:

    - #### webSocket

          public void webSocket(WebSocketConnectOptions options,
                                Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket with the specified options.
      Parameters:
        `options` - the request options
        `handler` -

    - #### webSocket

          public void webSocket(WebSocketConnectOptions options)

      Connect a WebSocket with the specified options.
      Parameters:
        `options` - the request options

    - #### rxWebSocket

          public Single<WebSocket> rxWebSocket(WebSocketConnectOptions options)

      Connect a WebSocket with the specified options.
      Parameters:
        `options` - the request options
      Returns:

    - #### webSocketAbs

          public void webSocketAbs(String url,
                                   MultiMap headers,
                                   WebsocketVersion version,
                                   List<String> subProtocols,
                                   Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `handler` - handler that will be called if WebSocket connection fails

    - #### webSocketAbs

          public void webSocketAbs(String url,
                                   MultiMap headers,
                                   WebsocketVersion version,
                                   List<String> subProtocols)

      Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use

    - #### rxWebSocketAbs

          public Single<WebSocket> rxWebSocketAbs(String url,
                                                  MultiMap headers,
                                                  WebsocketVersion version,
                                                  List<String> subProtocols)

      Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
      Returns:

    - #### connectionHandler

          public HttpClient connectionHandler(Handler<HttpConnection> handler)

      Set a connection handler for the client. This handler is called when a new connection is established.
      Parameters:
        `handler` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### redirectHandler

          public HttpClient redirectHandler(java.util.function.Function<HttpClientResponse,Future<RequestOptions>> handler)

      Set a redirect handler for the http client.

      The redirect handler is called when a `3xx` response is received and the request is configured to follow redirects with `HttpClientRequest.setFollowRedirects(boolean)`.

      The redirect handler is passed the `HttpClientResponse`, it can return an `HttpClientRequest` or `null`.

      - when null is returned, the original response is processed by the original request response handler
      - when a new `Future` is returned, the client will send this new request
      The new request will get a copy of the previous request headers unless headers are set. In this case, the client assumes that the redirect handler exclusively managers the headers of the new request.

      The handler must return a `Future` unsent so the client can further configure it and send it.

      Parameters:
        `handler` - the new redirect handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the client. Closing will close down any pooled connections. Clients should always be closed after use.
      Parameters:
        `handler` -

    - #### close

          public void close()

      Close the client. Closing will close down any pooled connections. Clients should always be closed after use.

    - #### rxClose

          public Single<Void> rxClose()

      Close the client. Closing will close down any pooled connections. Clients should always be closed after use.
      Returns:

    - #### newInstance

          public static HttpClient newInstance(HttpClient arg)

Copyright © 2020 Eclipse. All rights reserved.