## Uses of Interface
io.vertx.core.Handler

- Packages that use Handler
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.camel |
  io.vertx.cassandra |
  io.vertx.circuitbreaker |
  io.vertx.config |
  io.vertx.config.spi |
  io.vertx.config.spi.utils |
  io.vertx.config.vault.client |
  io.vertx.core |
  io.vertx.core.datagram |
  io.vertx.core.dns |
  io.vertx.core.eventbus |
  io.vertx.core.file |
  io.vertx.core.http |
  io.vertx.core.net |
  io.vertx.core.parsetools |
  io.vertx.core.shareddata |
  io.vertx.core.spi.resolver |
  io.vertx.core.streams |
  io.vertx.db2client |
  io.vertx.ext.auth |
  io.vertx.ext.auth.authentication |
  io.vertx.ext.auth.authorization |
  io.vertx.ext.auth.jdbc |
  io.vertx.ext.auth.mongo |
  io.vertx.ext.auth.oauth2 |
  io.vertx.ext.auth.oauth2.providers |
  io.vertx.ext.auth.sqlclient |
  io.vertx.ext.auth.webauthn |
  io.vertx.ext.bridge |
  io.vertx.ext.cluster.infinispan |
  io.vertx.ext.consul |
  io.vertx.ext.eventbus.bridge.tcp |
  io.vertx.ext.healthchecks |
  io.vertx.ext.httpservicefactory |
  io.vertx.ext.mail |
  io.vertx.ext.mongo |
  io.vertx.ext.reactivestreams |
  io.vertx.ext.shell |
  io.vertx.ext.shell.command |
  io.vertx.ext.shell.spi |
  io.vertx.ext.shell.system |
  io.vertx.ext.shell.term |
  io.vertx.ext.sql |
  io.vertx.ext.stomp |
  io.vertx.ext.unit |
  io.vertx.ext.unit.collect |
  io.vertx.ext.unit.report |
  io.vertx.ext.web |
  io.vertx.ext.web.api.contract |
  io.vertx.ext.web.api.contract.openapi3 |
  io.vertx.ext.web.api.service |
  io.vertx.ext.web.api.validation |
  io.vertx.ext.web.client |
  io.vertx.ext.web.client.spi |
  io.vertx.ext.web.codec |
  io.vertx.ext.web.codec.spi |
  io.vertx.ext.web.common.template |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.graphql |
  io.vertx.ext.web.handler.graphql.ws |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.openapi |
  io.vertx.ext.web.openapi.router |
  io.vertx.ext.web.proxy.handler |
  io.vertx.ext.web.sstore |
  io.vertx.grpc |
  io.vertx.grpc.client |
  io.vertx.grpc.common |
  io.vertx.grpc.server |
  io.vertx.grpc.stub |
  io.vertx.grpcio.client |
  io.vertx.grpcio.server |
  io.vertx.httpproxy |
  io.vertx.json.schema |
  io.vertx.json.schema.common |
  io.vertx.junit5 |
  io.vertx.kafka.admin |
  io.vertx.kafka.client.consumer |
  io.vertx.kafka.client.producer |
  io.vertx.lang.reactivex |
  io.vertx.lang.rxjava |
  io.vertx.lang.rxjava3 |
  io.vertx.micrometer |
  io.vertx.mqtt |
  io.vertx.mssqlclient |
  io.vertx.mysqlclient |
  io.vertx.pgclient |
  io.vertx.pgclient.pubsub |
  io.vertx.rabbitmq |
  io.vertx.reactivex |
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.cassandra |
  io.vertx.reactivex.circuitbreaker |
  io.vertx.reactivex.config |
  io.vertx.reactivex.core |
  io.vertx.reactivex.core.datagram |
  io.vertx.reactivex.core.dns |
  io.vertx.reactivex.core.eventbus |
  io.vertx.reactivex.core.file |
  io.vertx.reactivex.core.http |
  io.vertx.reactivex.core.net |
  io.vertx.reactivex.core.parsetools |
  io.vertx.reactivex.core.shareddata |
  io.vertx.reactivex.core.streams |
  io.vertx.reactivex.db2client |
  io.vertx.reactivex.ext.auth |
  io.vertx.reactivex.ext.auth.authentication |
  io.vertx.reactivex.ext.auth.authorization |
  io.vertx.reactivex.ext.auth.jdbc |
  io.vertx.reactivex.ext.auth.mongo |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.auth.oauth2.providers |
  io.vertx.reactivex.ext.auth.sqlclient |
  io.vertx.reactivex.ext.auth.webauthn |
  io.vertx.reactivex.ext.consul |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.healthchecks |
  io.vertx.reactivex.ext.jdbc |
  io.vertx.reactivex.ext.mail |
  io.vertx.reactivex.ext.mongo |
  io.vertx.reactivex.ext.shell |
  io.vertx.reactivex.ext.shell.command |
  io.vertx.reactivex.ext.shell.system |
  io.vertx.reactivex.ext.shell.term |
  io.vertx.reactivex.ext.sql |
  io.vertx.reactivex.ext.stomp |
  io.vertx.reactivex.ext.unit |
  io.vertx.reactivex.ext.unit.collect |
  io.vertx.reactivex.ext.unit.report |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.api.contract |
  io.vertx.reactivex.ext.web.api.contract.openapi3 |
  io.vertx.reactivex.ext.web.client |
  io.vertx.reactivex.ext.web.common.template |
  io.vertx.reactivex.ext.web.handler |
  io.vertx.reactivex.ext.web.handler.graphql |
  io.vertx.reactivex.ext.web.handler.graphql.ws |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.openapi |
  io.vertx.reactivex.ext.web.openapi.router |
  io.vertx.reactivex.ext.web.sstore |
  io.vertx.reactivex.grpc.client |
  io.vertx.reactivex.grpc.common |
  io.vertx.reactivex.grpc.server |
  io.vertx.reactivex.grpcio.client |
  io.vertx.reactivex.grpcio.server |
  io.vertx.reactivex.json.schema |
  io.vertx.reactivex.kafka.admin |
  io.vertx.reactivex.kafka.client.consumer |
  io.vertx.reactivex.kafka.client.producer |
  io.vertx.reactivex.micrometer |
  io.vertx.reactivex.mqtt |
  io.vertx.reactivex.mssqlclient |
  io.vertx.reactivex.mysqlclient |
  io.vertx.reactivex.oracleclient |
  io.vertx.reactivex.pgclient |
  io.vertx.reactivex.pgclient.pubsub |
  io.vertx.reactivex.rabbitmq |
  io.vertx.reactivex.redis.client |
  io.vertx.reactivex.servicediscovery |
  io.vertx.reactivex.servicediscovery.spi |
  io.vertx.reactivex.servicediscovery.types |
  io.vertx.reactivex.sqlclient |
  io.vertx.reactivex.sqlclient.templates |
  io.vertx.redis.client |
  io.vertx.rx.java |
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.cassandra |
  io.vertx.rxjava.circuitbreaker |
  io.vertx.rxjava.config |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.datagram |
  io.vertx.rxjava.core.dns |
  io.vertx.rxjava.core.eventbus |
  io.vertx.rxjava.core.file |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.core.net |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.core.shareddata |
  io.vertx.rxjava.core.streams |
  io.vertx.rxjava.db2client |
  io.vertx.rxjava.ext.auth |
  io.vertx.rxjava.ext.auth.authentication |
  io.vertx.rxjava.ext.auth.authorization |
  io.vertx.rxjava.ext.auth.jdbc |
  io.vertx.rxjava.ext.auth.mongo |
  io.vertx.rxjava.ext.auth.oauth2 |
  io.vertx.rxjava.ext.auth.oauth2.providers |
  io.vertx.rxjava.ext.auth.sqlclient |
  io.vertx.rxjava.ext.auth.webauthn |
  io.vertx.rxjava.ext.consul |
  io.vertx.rxjava.ext.eventbus.bridge.tcp |
  io.vertx.rxjava.ext.healthchecks |
  io.vertx.rxjava.ext.jdbc |
  io.vertx.rxjava.ext.mail |
  io.vertx.rxjava.ext.mongo |
  io.vertx.rxjava.ext.shell |
  io.vertx.rxjava.ext.shell.command |
  io.vertx.rxjava.ext.shell.system |
  io.vertx.rxjava.ext.shell.term |
  io.vertx.rxjava.ext.sql |
  io.vertx.rxjava.ext.stomp |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.unit.collect |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.api.contract |
  io.vertx.rxjava.ext.web.api.contract.openapi3 |
  io.vertx.rxjava.ext.web.client |
  io.vertx.rxjava.ext.web.common.template |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.graphql |
  io.vertx.rxjava.ext.web.handler.graphql.ws |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.ext.web.sstore |
  io.vertx.rxjava.grpc.client |
  io.vertx.rxjava.grpc.common |
  io.vertx.rxjava.grpc.server |
  io.vertx.rxjava.grpcio.client |
  io.vertx.rxjava.grpcio.server |
  io.vertx.rxjava.json.schema |
  io.vertx.rxjava.kafka.admin |
  io.vertx.rxjava.kafka.client.consumer |
  io.vertx.rxjava.kafka.client.producer |
  io.vertx.rxjava.micrometer |
  io.vertx.rxjava.mqtt |
  io.vertx.rxjava.mssqlclient |
  io.vertx.rxjava.mysqlclient |
  io.vertx.rxjava.oracleclient |
  io.vertx.rxjava.pgclient |
  io.vertx.rxjava.pgclient.pubsub |
  io.vertx.rxjava.rabbitmq |
  io.vertx.rxjava.redis.client |
  io.vertx.rxjava.servicediscovery |
  io.vertx.rxjava.servicediscovery.spi |
  io.vertx.rxjava.servicediscovery.types |
  io.vertx.rxjava.sqlclient |
  io.vertx.rxjava3 |
  io.vertx.rxjava3.amqp |
  io.vertx.rxjava3.cassandra |
  io.vertx.rxjava3.circuitbreaker |
  io.vertx.rxjava3.config |
  io.vertx.rxjava3.core |
  io.vertx.rxjava3.core.datagram |
  io.vertx.rxjava3.core.eventbus |
  io.vertx.rxjava3.core.file |
  io.vertx.rxjava3.core.http |
  io.vertx.rxjava3.core.net |
  io.vertx.rxjava3.core.parsetools |
  io.vertx.rxjava3.core.streams |
  io.vertx.rxjava3.db2client |
  io.vertx.rxjava3.ext.auth.oauth2 |
  io.vertx.rxjava3.ext.consul |
  io.vertx.rxjava3.ext.eventbus.bridge.tcp |
  io.vertx.rxjava3.ext.healthchecks |
  io.vertx.rxjava3.ext.shell |
  io.vertx.rxjava3.ext.shell.command |
  io.vertx.rxjava3.ext.shell.system |
  io.vertx.rxjava3.ext.shell.term |
  io.vertx.rxjava3.ext.stomp |
  io.vertx.rxjava3.ext.unit |
  io.vertx.rxjava3.ext.unit.collect |
  io.vertx.rxjava3.ext.unit.report |
  io.vertx.rxjava3.ext.web |
  io.vertx.rxjava3.ext.web.api.contract |
  io.vertx.rxjava3.ext.web.api.contract.openapi3 |
  io.vertx.rxjava3.ext.web.api.validation |
  io.vertx.rxjava3.ext.web.handler |
  io.vertx.rxjava3.ext.web.handler.graphql |
  io.vertx.rxjava3.ext.web.handler.graphql.ws |
  io.vertx.rxjava3.ext.web.handler.sockjs |
  io.vertx.rxjava3.ext.web.openapi |
  io.vertx.rxjava3.ext.web.openapi.router |
  io.vertx.rxjava3.ext.web.validation |
  io.vertx.rxjava3.grpc.client |
  io.vertx.rxjava3.grpc.common |
  io.vertx.rxjava3.grpc.server |
  io.vertx.rxjava3.grpcio.client |
  io.vertx.rxjava3.grpcio.server |
  io.vertx.rxjava3.httpproxy |
  io.vertx.rxjava3.kafka.client.consumer |
  io.vertx.rxjava3.kafka.client.producer |
  io.vertx.rxjava3.micrometer |
  io.vertx.rxjava3.mqtt |
  io.vertx.rxjava3.mssqlclient |
  io.vertx.rxjava3.mysqlclient |
  io.vertx.rxjava3.oracleclient |
  io.vertx.rxjava3.pgclient |
  io.vertx.rxjava3.pgclient.pubsub |
  io.vertx.rxjava3.rabbitmq |
  io.vertx.rxjava3.redis.client |
  io.vertx.rxjava3.servicediscovery.spi |
  io.vertx.rxjava3.servicediscovery.types |
  io.vertx.rxjava3.sqlclient |
  io.vertx.servicediscovery |
  io.vertx.servicediscovery.backend.redis |
  io.vertx.servicediscovery.consul |
  io.vertx.servicediscovery.docker |
  io.vertx.servicediscovery.kubernetes |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.types |
  io.vertx.servicediscovery.zookeeper |
  io.vertx.serviceproxy |
  io.vertx.spi.cluster.hazelcast |
  io.vertx.sqlclient |
  io.vertx.sqlclient.templates |

- - ### Uses of Handler in io.vertx.amqp

    Methods in io.vertx.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.

  - ### Uses of Handler in io.vertx.camel

    Methods in io.vertx.camel with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CamelBridge` | CamelBridge.`start(Handler<AsyncResult<Void>> completed)` Starts the bridge.
    `CamelBridge` | CamelBridge.`stop(Handler<AsyncResult<Void>> completed)` Stops the bridge.

  - ### Uses of Handler in io.vertx.cassandra

    Methods in io.vertx.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.fetchNextPage()` or `#one(Handler)`.
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `<R> CassandraClient` | CassandraClient.`execute(com.datastax.oss.driver.api.core.cql.Statement statement, java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,?,R> collector, Handler<AsyncResult<R>> resultHandler)` Execute a statement and produce a result by applying a collector to result set rows.
    `CassandraClient` | CassandraClient.`execute(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `<R> CassandraClient` | CassandraClient.`execute(String query, java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,?,R> collector, Handler<AsyncResult<R>> resultHandler)` Execute a query and produce a result by applying a collector to result set rows.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `void` | ResultSet.`fetchNextPage(Handler<AsyncResult<ResultSet>> handler)` Like `ResultSet.fetchNextPage()` but with a direct callback.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)`
    `void` | CassandraClient.`metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)` Get `Metadata` for the session.
    `default void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst, Handler<AsyncResult<Void>> handler)`
    `CassandraClient` | CassandraClient.`prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided a `SimpleStatement`.
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

  - ### Uses of Handler in io.vertx.circuitbreaker

    Subinterfaces of Handler in io.vertx.circuitbreaker
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HystrixMetricHandler` A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.

    Methods in io.vertx.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to close.
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `default <T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using a callback.
    `default <T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to open.

  - ### Uses of Handler in io.vertx.config

    Methods in io.vertx.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different `ConfigStore` and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> handler)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.config.spi

    Methods in io.vertx.config.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | ConfigStore.`close(Handler<Void> completionHandler)` Deprecated. implement `ConfigStore.close()` instead
    `default void` | ConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)` Deprecated. implement `ConfigStore.get()` instead
    `default void` | ConfigProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input, Handler<AsyncResult<JsonObject>> handler)` Deprecated. implement `ConfigProcessor.process(Vertx, JsonObject, Buffer)` instead

  - ### Uses of Handler in io.vertx.config.spi.utils

    Methods in io.vertx.config.spi.utils with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | FileSet.`buildConfiguration(List<File> files, Handler<AsyncResult<JsonObject>> handler)` Iterates over the given set of files, and for each matching file, computes the resulting configuration.

  - ### Uses of Handler in io.vertx.config.vault.client

    Methods in io.vertx.config.vault.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SlimVaultClient.`createToken(TokenRequest tokenRequest, Handler<AsyncResult<Auth>> resultHandler)` Creates a new token.
    `void` | SlimVaultClient.`delete(String path, Handler<AsyncResult<Void>> resultHandler)` Deletes a secret from `path`.
    `void` | SlimVaultClient.`list(String path, Handler<AsyncResult<List<String>>> resultHandler)` Lists secrets from path (children).
    `void` | SlimVaultClient.`loginWithAppRole(String roleId, String secretId, Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `AppRole` backend.
    `void` | SlimVaultClient.`loginWithCert(Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `Cert` backend.
    `void` | SlimVaultClient.`loginWithUserCredentials(String username, String password, Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `userpass` backend.
    `void` | SlimVaultClient.`lookupSelf(Handler<AsyncResult<Lookup>> resultHandler)` Looks up for the current token metadata.
    `void` | SlimVaultClient.`read(String path, Handler<AsyncResult<Secret>> responseHandler)` Reads a secret from `path`.
    `void` | SlimVaultClient.`renewSelf(long leaseDurationInSecond, Handler<AsyncResult<Auth>> resultHandler)` Renews the current token.
    `void` | SlimVaultClient.`write(String path, JsonObject secrets, Handler<AsyncResult<Secret>> resultHandler)` Write a secret to `path`.

  - ### Uses of Handler in io.vertx.core

    Subinterfaces of Handler in io.vertx.core
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Promise<T>` Represents the writable side of an action that may, or may not, have occurred yet.

    Methods in io.vertx.core that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<Throwable>` | Context.`exceptionHandler()`
    `Handler<Throwable>` | Vertx.`exceptionHandler()`

    Methods in io.vertx.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default Future<T>` | Future.`andThen(Handler<AsyncResult<T>> handler)` Invokes the given `handler` upon completion.
    `default void` | VertxBuilder.`buildClustered(Handler<AsyncResult<Vertx>> handler)` Creates a clustered instance.
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions, Handler)` but `Verticle` instance is created by invoking the default constructor of `verticleClass`.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `default void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions, Handler)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)` Deprecated.
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(Handler)` at creation.
    `default <T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Callable, boolean)` but using a callback.
    `default <T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(Callable, boolean)` but using a callback.
    `default <T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Callable, boolean)` but using a callback.
    `default <T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Callable)` but using a callback.
    `default <T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(Callable)` but using a callback.
    `default <T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Callable)` but using a callback.
    `default <T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable)`
    `default <T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated. instead use `Context.executeBlocking(Callable)`
    `default <T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated. instead use `Vertx.executeBlocking(Callable)`
    `<T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable, boolean)`
    `<T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. instead use `Context.executeBlocking(Callable, boolean)`
    `default <T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. instead use `Vertx.executeBlocking(Callable, boolean)`
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable, boolean)`
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable, boolean)`
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Context.executeBlocking(Callable, boolean)`
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Context.executeBlocking(Callable, boolean)`
    `default <T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. use instead `Vertx.executeBlocking(Callable, boolean)`
    `default <T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. use instead `Vertx.executeBlocking(Callable, boolean)`
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable)`
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable)`
    `default <T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Context.executeBlocking(Callable)`
    `default <T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Context.executeBlocking(Callable)`
    `default <T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Vertx.executeBlocking(Callable)`
    `default <T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `Vertx.executeBlocking(Callable)`
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)` Deprecated.
    `CompositeFuture` | CompositeFuture.`onComplete(Handler<AsyncResult<CompositeFuture>> handler)`
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `default Future<T>` | Future.`onComplete(Handler<T> successHandler, Handler<Throwable> failureHandler)` Add handlers to be notified on succeeded result and failed result.
    `default Future<T>` | Future.`onComplete(Handler<T> successHandler, Handler<Throwable> failureHandler)` Add handlers to be notified on succeeded result and failed result.
    `default CompositeFuture` | CompositeFuture.`onFailure(Handler<Throwable> handler)`
    `default Future<T>` | Future.`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
    `default CompositeFuture` | CompositeFuture.`onSuccess(Handler<CompositeFuture> handler)`
    `default Future<T>` | Future.`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `default long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setPeriodic(long initialDelay, long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.core.datagram

    Methods in io.vertx.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)` Deprecated. removed in Vert.x 5
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.core.dns

    Methods in io.vertx.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | DnsClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.core.eventbus

    Methods in io.vertx.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close()` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(MessageConsumerOptions options, Handler<Message<T>> handler)` Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(String, Handler)` but the address won't be propagated across the cluster.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(Handler)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(Handler)`
    `default <R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like `Message.replyAndRequest(Object, Handler)` but specifying `options` that can be used to configure the delivery.
    `default <R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `default <T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.request(String, Object, Handler)` but specifying `options` that can be used to configure the delivery.
    `default <T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `void` | MessageProducer.`write(T body, Handler<AsyncResult<Void>> handler)` Write a message to the event-bus, either sending or publishing.

  - ### Uses of Handler in io.vertx.core.file

    Methods in io.vertx.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deprecated. instead use `FileSystem.deleteRecursive(String, Handler)` or `FileSystem.delete(String, Handler)`
    `default FileSystem` | FileSystem.`deleteRecursive(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `void` | AsyncFileLock.`isValid(Handler<AsyncResult<Boolean>> handler)` Like `AsyncFileLock.isValid()` but the `handler` will be called when the operation completes or if an error occurs.
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `void` | AsyncFile.`lock(Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock()` but the `handler` will be called when the operation is complete or if an error occurs.
    `void` | AsyncFile.`lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock(long, long, boolean)` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `void` | AsyncFileLock.`release(Handler<AsyncResult<Void>> handler)` Like `AsyncFileLock.release()` but the `handler` will be called when the operation completes or if an error occurs.
    `default void` | AsyncFile.`size(Handler<AsyncResult<Long>> handler)` Like `AsyncFile.size()` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `void` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.core.http

    Fields in io.vertx.core.http declared as Handler
    Modifier and Type | Field and Description
    --- | ---
    `static Handler<HttpServerRequest>` | HttpServerRequest.`DEFAULT_INVALID_REQUEST_HANDLER` The default invalid request handler, it uses the `HttpServerRequest.decoderResult()` cause and the request information to determine the status code of the response to be sent.

    Methods in io.vertx.core.http that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<HttpServerRequest>` | HttpServer.`requestHandler()`
    `Handler<ServerWebSocket>` | HttpServer.`webSocketHandler()`

    Methods in io.vertx.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `default HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body()` but with an `handler` called when the operation completes
    `default HttpClientResponse` | HttpClientResponse.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpClientResponse.body()` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `default HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `default HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | WebSocketClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `default void` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | HttpClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(short)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(short, String)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`closeHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `default void` | ClientWebSocket.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `default void` | WebSocketClient.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `default void` | ClientWebSocket.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and port.
    `default void` | WebSocketClient.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `default void` | ClientWebSocket.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket to the host and relative request URI and default port.
    `default void` | WebSocketClient.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port and specified host and relative request URI.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Deprecated. instead use `HttpClientBuilder.withConnectHandler(Handler)`
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a Continue handler has been set using this method, then the `handler` will be called.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler(Handler<MultiMap> handler)` If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(Buffer)` but with an `handler` called when the operation completes
    `default void` | HttpServerRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerRequest.end()` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end()` but with an `handler` called when the operation completes
    `default void` | HttpClientResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientResponse.end()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(String)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String,String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(String, String)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `ClientWebSocket` | ClientWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ClientWebSocket` | ClientWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a GOAWAY frame is received.
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ClientWebSocket` | ClientWebSocket.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler(Handler<HttpServerRequest> handler)` Set a `handler` for handling invalid requests.
    `default HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `default HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `default HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, String)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `default HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a PING frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a PING frame is received from the remote endpoint.
    `ClientWebSocket` | ClientWebSocket.`pongHandler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with no headers.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort authority, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with the host copied from the current request.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with the host copied from the current request.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated. instead use `HttpServerResponse.push(HttpMethod, HostAndPort, String, Handler)`
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `void` | HttpClient.`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` | HttpClient.`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` | HttpClient.`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` | HttpClient.`request(RequestOptions options, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpClientRequest` | HttpClientRequest.`response(Handler<AsyncResult<HttpClientResponse>> handler)` Set a callback for the associated `HttpClientResponse`.
    `default void` | HttpClientRequest.`send(Buffer body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a buffer `body`.
    `default void` | HttpServerResponse.`send(Buffer body, Handler<AsyncResult<Void>> handler)` Send the request with a buffer `body`.
    `default void` | HttpClientRequest.`send(Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with an empty body.
    `default void` | HttpServerResponse.`send(Handler<AsyncResult<Void>> handler)` Send the request with an empty body.
    `default void` | HttpClientRequest.`send(ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a stream `body`.
    `default void` | HttpServerResponse.`send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler)` Send the request with a stream `body`.
    `default void` | HttpClientRequest.`send(String body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a string `body`.
    `default void` | HttpServerResponse.`send(String body, Handler<AsyncResult<Void>> handler)` Send the request with a string `body`.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<AsyncResult<Void>> completionHandler)` Like `HttpClientRequest.sendHead()` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Deprecated. instead use `ServerWebSocketHandshake`
    `default void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Shutdown a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `default void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Deprecated. instead use `HttpConnection.shutdown(long, TimeUnit, Handler)`
    `default void` | HttpConnection.`shutdown(long timeout, TimeUnit unit, Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a GOAWAY frame has been sent or received and all connections are closed.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler(Handler<String> handler)`
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `default void` | HttpServerRequest.`toNetSocket(Handler<AsyncResult<NetSocket>> handler)` Establish a TCP tunnel with the client.
    `default void` | HttpServerRequest.`toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)` Upgrade the connection of the current request to a WebSocket.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `default void` | WebSocketClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | HttpServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | HttpClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | WebSocketClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | HttpServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | HttpClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated. instead use `WebSocketClient.connect(int, String, String, Handler)`
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated. instead use `WebSocketClient.connect(int, String, String, Handler)`
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated. instead use `WebSocketClient.connect(int, String, String, Handler)`
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Deprecated. instead use `WebSocketClient.connect(WebSocketConnectOptions, Handler)`
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Deprecated. instead use `WebSocketClient.connect(WebSocketConnectOptions, Handler)`
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler(Handler<ServerWebSocketHandshake> handler)` Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `void` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(String)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(String,String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(String, String)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(Buffer)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`writeEarlyHints(MultiMap headers, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.writeEarlyHints(MultiMap)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(Buffer, Handler)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(String, Handler)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(WebSocketFrame)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.core.net

    Methods in io.vertx.core.net that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<NetSocket>` | NetServer.`connectHandler()`

    Methods in io.vertx.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end()`.
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `NetServer` | NetServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the connection is passed to the `NetServer.connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>)`, e.g during the TLS handshake.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `default NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `default NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int)` but providing a handler that will be notified when the server is listening, or fails.
    `default NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int, String)` but providing a handler that will be notified when the server is listening, or fails.
    `default NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(SocketAddress)` but providing a handler that will be notified when the server is listening, or fails.
    `default NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `default NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `default void` | NetClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | NetServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | NetClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | NetServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `void` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like `WriteStream.write(Object)` but with an `handler` called when the message has been written or failed to be written.
    `void` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(String)` but with an `handler` called when the operation completes
    `void` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(String, String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.core.parsetools

    Subinterfaces of Handler in io.vertx.core.parsetools
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `JsonParser` A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully.
    `interface` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(Buffer)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(String)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.core.shareddata

    Methods in io.vertx.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `default void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `default void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `default void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `default void` | AsyncMap.`entries(Handler<AsyncResult<Map<K,V>>> resultHandler)` Get the entries of the map, asynchronously.
    `default void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `default void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `default void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `default void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(String, Handler)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(String, Handler)` but specifying a timeout.
    `default void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `default void` | AsyncMap.`keys(Handler<AsyncResult<Set<K>>> resultHandler)` Get the keys of the map, asynchronously.
    `default void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `default void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `default void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `default void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `default void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `default void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `default void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `default void` | AsyncMap.`replace(K k, V v, long ttl, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `default void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `default void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, long ttl, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `default void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map
    `default void` | AsyncMap.`values(Handler<AsyncResult<List<V>>> resultHandler)` Get the values of the map, asynchronously.

  - ### Uses of Handler in io.vertx.core.spi.resolver

    Methods in io.vertx.core.spi.resolver with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ResolverProvider.`close(Handler<Void> doneHandler)`

  - ### Uses of Handler in io.vertx.core.streams

    Methods in io.vertx.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `default void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as `#end(T)` but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `default void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `void` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as `#write(T)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.db2client

    Methods in io.vertx.db2client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static SqlClient` | DB2Builder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler(Handler<Void> handler)`
    `static void` | DB2Connection.`connect(Vertx vertx, DB2ConnectOptions connectOptions, Handler<AsyncResult<DB2Connection>> handler)` Create a connection to DB2 server with the given `connectOptions`.
    `static void` | DB2Connection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<DB2Connection>> handler)` Like `DB2Connection.connect(Vertx, DB2ConnectOptions, Handler)` with options build from `connectionUri`.
    `DB2Pool` | DB2Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`exceptionHandler(Handler<Throwable> handler)`
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | DB2Builder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.ext.auth

    Methods in io.vertx.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `User` | User.`isAuthorized(Authorization authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `default User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated. Use typed alternative `User.isAuthorized(Authorization, Handler)`

  - ### Uses of Handler in io.vertx.ext.auth.authentication

    Methods in io.vertx.ext.auth.authentication with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | AuthenticationProvider.`authenticate(Credentials credentials, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `void` | AuthenticationProvider.`authenticate(JsonObject credentials, Handler<AsyncResult<User>> resultHandler)` Deprecated. For type safety this method should be avoided and `AuthenticationProvider.authenticate(Credentials, Handler)` should be used instead.

  - ### Uses of Handler in io.vertx.ext.auth.authorization

    Methods in io.vertx.ext.auth.authorization with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthorizationProvider.`getAuthorizations(User user, Handler<AsyncResult<Void>> handler)` Updates the user with the set of authorizations.

  - ### Uses of Handler in io.vertx.ext.auth.jdbc

    Methods in io.vertx.ext.auth.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JDBCUserUtil` | JDBCUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Insert a user into a database.
    `JDBCUserUtil` | JDBCUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Insert a role permission into a database.
    `JDBCUserUtil` | JDBCUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Insert a user into a database.
    `JDBCUserUtil` | JDBCUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Insert a user role into a database.

  - ### Uses of Handler in io.vertx.ext.auth.mongo

    Methods in io.vertx.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default MongoUserUtil` | MongoUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `default MongoUserUtil` | MongoUserUtil.`createUser(String username, String password, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `default MongoUserUtil` | MongoUserUtil.`createUserRolesAndPermissions(String username, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a user role into a database.
    `default void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Deprecated. Please use `MongoUserUtil` instead. Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.ext.auth.oauth2

    Methods in io.vertx.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default OAuth2Auth` | OAuth2Auth.`jWKSet(Handler<AsyncResult<Void>> handler)` Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler(Handler<String> handler)` Handled to be called when a key (mentioned on a JWT) is missing from the current config.
    `default OAuth2Auth` | OAuth2Auth.`refresh(User user, Handler<AsyncResult<User>> handler)` Refresh the current User (access token).
    `default OAuth2Auth` | OAuth2Auth.`revoke(User user, Handler<AsyncResult<Void>> handler)` Revoke an obtained access token.
    `default OAuth2Auth` | OAuth2Auth.`revoke(User user, String tokenType, Handler<AsyncResult<Void>> handler)` Revoke an obtained access or refresh token.
    `default OAuth2Auth` | OAuth2Auth.`userInfo(User user, Handler<AsyncResult<JsonObject>> handler)` Retrieve profile information and other attributes for a logged-in end-user.

  - ### Uses of Handler in io.vertx.ext.auth.oauth2.providers

    Methods in io.vertx.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AmazonCognitoAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | IBMCloudAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.ext.auth.sqlclient

    Methods in io.vertx.ext.auth.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default SqlUserUtil` | SqlUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `default SqlUserUtil` | SqlUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Insert a role permission into a database.
    `default SqlUserUtil` | SqlUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `default SqlUserUtil` | SqlUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Insert a user role into a database.

  - ### Uses of Handler in io.vertx.ext.auth.webauthn

    Methods in io.vertx.ext.auth.webauthn with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default WebAuthn` | WebAuthn.`createCredentialsOptions(JsonObject user, Handler<AsyncResult<JsonObject>> handler)` Gets a challenge and any other parameters for the `navigator.credentials.create()` call.
    `default MetaDataService` | MetaDataService.`fetchTOC(Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
    `default MetaDataService` | MetaDataService.`fetchTOC(String url, Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
    `default WebAuthn` | WebAuthn.`getCredentialsOptions(String name, Handler<AsyncResult<JsonObject>> handler)` Creates an assertion challenge and any other parameters for the `navigator.credentials.get()` call.

  - ### Uses of Handler in io.vertx.ext.bridge

    Subinterfaces of Handler in io.vertx.ext.bridge
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BaseBridgeEvent` Represents an event that occurs on the event bus bridge.

  - ### Uses of Handler in io.vertx.ext.cluster.infinispan

    Subinterfaces of Handler in io.vertx.ext.cluster.infinispan
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ClusterHealthCheck` A helper to create Vert.x cluster `HealthChecks` procedures.

  - ### Uses of Handler in io.vertx.ext.consul

    Methods in io.vertx.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(String, Handler)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(Handler)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String accessorId, CloneAclTokenOptions cloneAclToken, Handler<AsyncResult<AclToken>> resultHandler)` Clones an existing ACL token
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Deprecated. Use `ConsulClient.cloneAclToken(String, CloneAclTokenOptions)` instead
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(Handler)`
    `ConsulClient` | ConsulClient.`createAclPolicy(AclPolicy policy, Handler<AsyncResult<String>> resultHandler)` Creates a new ACL policy
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Create an Acl token
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated. Use `ConsulClient.createAclToken(io.vertx.ext.consul.token.AclToken)` instead
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`deleteAclToken(String accessorId, Handler<AsyncResult<Boolean>> resultHandler)` Deletes an ACL token
    `ConsulClient` | ConsulClient.`deletePolicy(String id, Handler<AsyncResult<Boolean>> resultHandler)` This endpoint deletes an ACL policy
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulClient` | ConsulClient.`deregisterCatalogService(String nodeId, String serviceId, Handler<AsyncResult<Void>> resultHandler)` Deregister entities from the node or deregister the node itself.
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Use `ConsulClient.deleteAclToken(String)` instead
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`getAclPolicies(Handler<AsyncResult<List<AclPolicy>>> resultHandler)` This endpoint lists all the ACL policies.
    `ConsulClient` | ConsulClient.`getAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthNodesWithOptions(String node, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks specific to the node provided on the path.
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Deprecated. Use `ConsulClient.readAclToken(String)` instead
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(String, Handler)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Deprecated. Use `ConsulClient.getAclTokens()` instead
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(String, Handler)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(Handler)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`readAclToken(String accessorId, Handler<AsyncResult<AclToken>> resultHandler)` Reads an ACL token with the given Accessor ID
    `ConsulClient` | ConsulClient.`readPolicy(String id, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given ID
    `ConsulClient` | ConsulClient.`readPolicyByName(String name, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given name
    `ConsulClient` | ConsulClient.`registerCatalogService(Node nodeOptions, ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Register node with external service
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated. Use `ConsulClient.updateAclToken(String, io.vertx.ext.consul.token.AclToken)` instead
    `ConsulClient` | ConsulClient.`updateAclToken(String accessorId, AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Update an existing Acl token
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updatePolicy(String id, AclPolicy policy, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint updates an existing ACL policy
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".

  - ### Uses of Handler in io.vertx.ext.eventbus.bridge.tcp

    Methods in io.vertx.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.ext.healthchecks

    Subinterfaces of Handler in io.vertx.ext.healthchecks
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HealthCheckHandler` A Vert.x Web handler on which you register health check procedure.

    Methods in io.vertx.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HealthChecks.`checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedures.
    `void` | HealthChecks.`checkStatus(String name, Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.ext.httpservicefactory

    Methods in io.vertx.ext.httpservicefactory with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | HttpServiceFactory.`doRequest(HttpClient client, File file, URI url, File signatureFile, URI signatureURL, Handler<AsyncResult<io.vertx.ext.httpservicefactory.HttpServiceFactory.Result>> handler)`

  - ### Uses of Handler in io.vertx.ext.mail

    Methods in io.vertx.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MailClient.`close(Handler<AsyncResult<Void>> closedHandler)` Close the MailClient
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.ext.mongo

    Methods in io.vertx.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `void` | MongoClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release its resources
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`countWithOptions(String collection, JsonObject query, CountOptions countOptions, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | MongoClient.`createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions, Handler<AsyncResult<Void>> resultHandler)` Create a new collection with options
    `MongoClient` | MongoClient.`createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createGridFsBucketService(String bucketName, Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoClient` | MongoClient.`createIndexes(String collection, List<IndexModel> indexes, Handler<AsyncResult<Void>> resultHandler)` creates an indexes
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoGridFsClient` | MongoGridFsClient.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes a file by it's ID
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadFile(String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileAs(String fileName, String newFileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file and gives it a new name.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileByID(String id, String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file using the ID generated by GridFs.
    `MongoGridFsClient` | MongoGridFsClient.`drop(Handler<AsyncResult<Void>> resultHandler)` Drops the entire file bucket with all of its contents
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoGridFsClient` | MongoGridFsClient.`findAllIds(Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids in the bucket
    `MongoGridFsClient` | MongoGridFsClient.`findIds(JsonObject query, Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids that match a query.
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonArray update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadFile(String fileName, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs
    `MongoGridFsClient` | MongoGridFsClient.`uploadFileWithOptions(String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs with options

  - ### Uses of Handler in io.vertx.ext.reactivestreams

    Methods in io.vertx.ext.reactivestreams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ReactiveWriteStream<T>` | ReactiveWriteStream.`drainHandler(Handler<Void> handler)`
    `void` | ReactiveWriteStream.`end(Handler<AsyncResult<Void>> handler)` Calls `ReactiveWriteStream.close()`.
    `ReactiveReadStream<T>` | ReactiveReadStream.`endHandler(Handler<Void> endHandler)`
    `ReactiveReadStream<T>` | ReactiveReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `ReactiveWriteStream<T>` | ReactiveWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `ReactiveReadStream<T>` | ReactiveReadStream.`handler(Handler<T> handler)`
    `void` | ReactiveWriteStream.`write(T data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.ext.shell

    Methods in io.vertx.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.ext.shell.command

    Methods in io.vertx.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Class<? extends AnnotatedCommand> command, Handler<AsyncResult<Command>> completionHandler)` Register a single command.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.ext.shell.spi

    Methods in io.vertx.ext.shell.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | CommandResolverFactory.`resolver(Vertx vertx, Handler<AsyncResult<CommandResolver>> resolveHandler)` Obtain a command resolver for a Vert.x instance.

  - ### Uses of Handler in io.vertx.ext.shell.system

    Methods in io.vertx.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `default void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.ext.shell.term

    Subinterfaces of Handler in io.vertx.ext.shell.term
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `SockJSTermHandler`

    Methods in io.vertx.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close()` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Bind the term server, the `TermServer.termHandler(Handler)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.ext.sql

    Methods in io.vertx.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `default SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `default SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `default SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `default SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `default SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `default SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `default SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `default SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `default SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.ext.stomp

    Subinterfaces of Handler in io.vertx.ext.stomp
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Classes in io.vertx.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultAbortHandler` STOMP compliant actions executed when receiving a `ABORT` frame.
    `class` | `DefaultAckHandler` STOMP compliant actions executed when receiving a `ACK` frame.
    `class` | `DefaultBeginHandler` STOMP compliant actions executed when receiving a `BEGIN` frame.
    `class` | `DefaultCommitHandler` STOMP compliant actions executed when receiving a `COMMIT` frame.
    `class` | `DefaultConnectHandler` STOMP compliant actions executed when receiving a `CONNECT` frame.
    `class` | `DefaultNackHandler` STOMP compliant actions executed when receiving a `NACK` sf.frame().
    `class` | `DefaultSendHandler` STOMP compliant actions executed when receiving a `SEND` sf.frame().
    `class` | `DefaultSubscribeHandler` STOMP compliant actions executed when receiving a `SUBSCRIBE` frame.
    `class` | `DefaultUnsubscribeHandler` STOMP compliant actions executed when receiving a `UNSUBSCRIBE` frame.

    Methods in io.vertx.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the `Handler` able to manage web socket connections.

    Methods in io.vertx.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `Future<String>` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `Future<String>` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.ext.unit

    Methods in io.vertx.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.ext.unit.collect

    Methods in io.vertx.ext.unit.collect that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<Message<JsonObject>>` | EventBusCollector.`asMessageHandler()`

    Methods in io.vertx.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.ext.unit.report

    Methods in io.vertx.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`

  - ### Uses of Handler in io.vertx.ext.web

    Subinterfaces of Handler in io.vertx.ext.web
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Router` A router receives request from an `HttpServer` and routes it to the first matching `Route` that it contains.

    Methods in io.vertx.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(Handler, boolean)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `default RoutingContext` | RoutingContext.`end(Buffer buffer, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(Buffer)`
    `default RoutingContext` | RoutingContext.`end(Handler<AsyncResult<Void>> handler)` See `RoutingContext.end()`
    `default RoutingContext` | RoutingContext.`end(String chunk, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(String)`
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `default void` | UserContext.`impersonate(Handler<AsyncResult<Void>> callback)`
    `default void` | UserContext.`impersonate(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `default RoutingContext` | RoutingContext.`json(Object json, Handler<AsyncResult<Void>> handler)` See `RoutingContext.json(Object)`.
    `default void` | UserContext.`logout(Handler<AsyncResult<Void>> callback)`
    `default void` | UserContext.`logout(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.
    `default RoutingContext` | RoutingContext.`redirect(String url, Handler<AsyncResult<Void>> handler)` See `RoutingContext.redirect(String)`.
    `default void` | UserContext.`restore(Handler<AsyncResult<Void>> callback)`
    `default void` | UserContext.`restore(String redirectUri, Handler<AsyncResult<Void>> callback)`

  - ### Uses of Handler in io.vertx.ext.web.api.contract

    Methods in io.vertx.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated. Router Factory won't manage the validation errors anymore. You must use `Router.errorHandler(int, Handler)` with 400 error

    Methods in io.vertx.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated. Add global handler to be applied prior to `Router` being generated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated. Mount to paths that have to follow a security schema a security handler
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated. You must use `Router.errorHandler(int, Handler)` with 501 error
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated. Router Factory won't manage the validation errors anymore. You must use `Router.errorHandler(int, Handler)` with 400 error

  - ### Uses of Handler in io.vertx.ext.web.api.contract.openapi3

    Subinterfaces of Handler in io.vertx.ext.web.api.contract.openapi3
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `OpenAPI3RequestValidationHandler` Deprecated. You should use the new module vertx-web-openapi

    Methods in io.vertx.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Deprecated. Add a failure handler by operation_id field in Operation object
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Deprecated. Add an handler by operation_id field in Operation object
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Deprecated. Add a particular scope validator.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated. Create a new OpenAPI3RouterFactory
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated. Create a new OpenAPI3RouterFactory

  - ### Uses of Handler in io.vertx.ext.web.api.service

    Subinterfaces of Handler in io.vertx.ext.web.api.service
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `RouteToEBServiceHandler` Handler that proxy the request to an event bus endpoint, waits for the reply and then writes the HTTP response.

  - ### Uses of Handler in io.vertx.ext.web.api.validation

    Subinterfaces of Handler in io.vertx.ext.web.api.validation
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HTTPRequestValidationHandler` Deprecated. You should use the new module vertx-web-openapi

  - ### Uses of Handler in io.vertx.ext.web.client

    Methods in io.vertx.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendForm(MultiMap body, String charset, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` stream.
    `default void` | WebClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `default void` | WebClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).

  - ### Uses of Handler in io.vertx.ext.web.client.spi

    Methods in io.vertx.ext.web.client.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | CacheStore.`delete(io.vertx.ext.web.client.impl.cache.CacheKey key, Handler<AsyncResult<Void>> handler)` Delete all variations of a key from the cache.
    `default void` | CacheStore.`flush(Handler<AsyncResult<Void>> handler)` Delete all entries from the cache.
    `default void` | CacheStore.`get(io.vertx.ext.web.client.impl.cache.CacheKey key, Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)` Retrieve a cached response.
    `default void` | CacheStore.`set(io.vertx.ext.web.client.impl.cache.CacheKey key, io.vertx.ext.web.client.impl.cache.CachedHttpResponse response, Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)` Add a response in the cache with the given key.

  - ### Uses of Handler in io.vertx.ext.web.codec

    Methods in io.vertx.ext.web.codec with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | BodyCodec.`create(Handler<AsyncResult<BodyStream<T>>> handler)` Create the `BodyStream`.

  - ### Uses of Handler in io.vertx.ext.web.codec.spi

    Subinterfaces of Handler in io.vertx.ext.web.codec.spi
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BodyStream<T>` The body stream decodes a `WriteStream` into the a `T` instance.

  - ### Uses of Handler in io.vertx.ext.web.common.template

    Methods in io.vertx.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.ext.web.handler

    Subinterfaces of Handler in io.vertx.ext.web.handler
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `APIKeyHandler` An authentication handler that provides API Key support.
    `interface` | `AuthorizationHandler` Base interface for authorization handlers that provide authorization support.
    `interface` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `interface` | `BodyHandler` A handler which gathers the entire request body and sets it on the `RoutingContext`.
    `interface` | `ChainAuthHandler` An auth handler that chains to a sequence of handlers.
    `interface` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `interface` | `CSPHandler` Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
    `interface` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `interface` | `DigestAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `interface` | `ErrorHandler` A pretty error handler for rendering error pages.
    `interface` | `FaviconHandler` A handler that serves favicons.
    `interface` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `interface` | `HSTSHandler` HTTP Strict Transport Security (HSTS) RFC6797.
    `interface` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `interface` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `interface` | `MethodOverrideHandler`
    `interface` | `MultiTenantHandler` A handler which selectively executes another handler if a precondition is met.
    `interface` | `OAuth2AuthHandler` An auth handler that provides OAuth2 Authentication support.
    `interface` | `OtpAuthHandler` An auth handler that provides One Time Password (Multi-Factor) Authentication support.
    `interface` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `interface` | `ResponseContentTypeHandler` A handler which sets the response content type automatically according to the best `Accept` header match.
    `interface` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `interface` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `interface` | `SimpleAuthenticationHandler` A user customizable authentication handler.
    `interface` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `interface` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `interface` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `interface` | `WebAuthnHandler` An auth handler that provides FIDO2 WebAuthN Relay Party support.
    `interface` | `XFrameHandler` The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a `<frame>`, `<iframe>`, `<embed>` or `<object>`.

    Methods in io.vertx.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `default SessionHandler` | SessionHandler.`flush(RoutingContext ctx, boolean ignoreStatus, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `default SessionHandler` | SessionHandler.`flush(RoutingContext ctx, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `default SessionHandler` | SessionHandler.`setUser(RoutingContext context, User user, Handler<AsyncResult<Void>> handler)` Set the user for the session

  - ### Uses of Handler in io.vertx.ext.web.handler.graphql

    Subinterfaces of Handler in io.vertx.ext.web.handler.graphql
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApolloWSConnectionInitEvent` Deprecated. the subscriptions-transport-ws protocol is no longer maintained
    `interface` | `ApolloWSHandler` Deprecated. the subscriptions-transport-ws protocol is no longer maintained
    `interface` | `GraphiQLHandler` A handler for GraphiQL resources.
    `interface` | `GraphQLHandler` A `Route` handler for GraphQL requests.

    Methods in io.vertx.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)` Deprecated. Set a callback to invoke before executing a GraphQL query.
    `GraphQLHandler` | GraphQLHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)` Deprecated. as of 4.5.1, use `GraphQLHandler.builder(GraphQL)` instead
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Deprecated. Customize the connection `Handler`.
    `ApolloWSHandler` | ApolloWSHandler.`connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)` Deprecated. Customize the connection init `Handler`.
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated. Customize the end `Handler`.
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Deprecated. Customize the message `Handler`.

  - ### Uses of Handler in io.vertx.ext.web.handler.graphql.ws

    Subinterfaces of Handler in io.vertx.ext.web.handler.graphql.ws
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ConnectionInitEvent`
    `interface` | `GraphQLWSHandler` A handler for the GraphQL over WebSocket Protocol.

    Methods in io.vertx.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandler` | GraphQLWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)` Deprecated. as of 4.5.1, use `GraphQLWSHandler.builder(GraphQL)` instead
    `GraphQLWSHandler` | GraphQLWSHandler.`connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)` Deprecated. as of 4.5.1, use `GraphQLWSHandler.builder(GraphQL)` instead
    `GraphQLWSHandler` | GraphQLWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated. as of 4.5.1, use `GraphQLWSHandler.builder(GraphQL)` instead
    `GraphQLWSHandler` | GraphQLWSHandler.`messageHandler(Handler<Message> messageHandler)` Deprecated. as of 4.5.1, use `GraphQLWSHandler.builder(GraphQL)` instead
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit(Handler<ConnectionInitEvent> connectionInitHandler)` Customize the connection init `Handler`.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage(Handler<Message> messageHandler)` Customize the message `Handler`.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd(Handler<ServerWebSocket> endHandler)` Customize the end `Handler`.

  - ### Uses of Handler in io.vertx.ext.web.handler.sockjs

    Subinterfaces of Handler in io.vertx.ext.web.handler.sockjs
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BridgeEvent` Represents an event that occurs on the event bus bridge.
    `interface` | `SockJSHandler` A handler that allows you to handle SockJS connections from clients.

    Methods in io.vertx.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `default Router` | SockJSHandler.`bridge(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler(Handler<Void> closeHandler)`
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `default void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `default void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.ext.web.openapi

    Methods in io.vertx.ext.web.openapi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | RouterBuilder.`create(Vertx vertx, String url, Handler<AsyncResult<RouterBuilder>> handler)` Like `this#create(Vertx, String)`
    `static void` | RouterBuilder.`create(Vertx vertx, String url, OpenAPILoaderOptions options, Handler<AsyncResult<RouterBuilder>> handler)` Like `this#create(Vertx, String, OpenAPILoaderOptions)`
    `Operation` | Operation.`failureHandler(Handler<RoutingContext> handler)` Mount a failure handler for this operation
    `Operation` | Operation.`handler(Handler<RoutingContext> handler)` Mount an handler for this operation
    `RouterBuilder` | RouterBuilder.`rootHandler(Handler<RoutingContext> rootHandler)` Add global handler to be applied prior to `Router` being generated.

  - ### Uses of Handler in io.vertx.ext.web.openapi.router

    Methods in io.vertx.ext.web.openapi.router that return types with arguments of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `List<Handler<RoutingContext>>` | OpenAPIRoute.`getFailureHandlers()`
    `List<Handler<RoutingContext>>` | OpenAPIRoute.`getHandlers()`

    Methods in io.vertx.ext.web.openapi.router with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPIRoute` | OpenAPIRoute.`addFailureHandler(Handler<RoutingContext> handler)` Adds a failure handler for this route
    `OpenAPIRoute` | OpenAPIRoute.`addHandler(Handler<RoutingContext> handler)` Adds a handler for this route which is executed after the security and validation handlers defined in the contract
    `RouterBuilder` | RouterBuilder.`rootHandler(Handler<RoutingContext> rootHandler)` Add global handler to be applied prior to `Router` being generated.

  - ### Uses of Handler in io.vertx.ext.web.proxy.handler

    Subinterfaces of Handler in io.vertx.ext.web.proxy.handler
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ProxyHandler`

  - ### Uses of Handler in io.vertx.ext.web.sstore

    Methods in io.vertx.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default SessionStore` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `default SessionStore` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `default SessionStore` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `default SessionStore` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `default SessionStore` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.grpc

    Methods in io.vertx.grpc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `VertxServer` | VertxServer.`shutdown(Handler<AsyncResult<Void>> completionHandler)`
    `VertxServer` | VertxServer.`start(Handler<AsyncResult<Void>> completionHandler)`
    `VertxChannelBuilder` | VertxChannelBuilder.`useSsl(Handler<ClientOptionsBase> handler)`
    `VertxServerBuilder` | VertxServerBuilder.`useSsl(Handler<HttpServerOptions> handler)`

  - ### Uses of Handler in io.vertx.grpc.client

    Methods in io.vertx.grpc.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default <Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Deprecated. instead use `GrpcIoClient.call(SocketAddress, MethodDescriptor, Handler, Function)`
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`drainHandler(Handler<Void> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`endHandler(Handler<Void> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`errorHandler(Handler<GrpcError> handler)`
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`handler(Handler<Resp> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`messageHandler(Handler<GrpcMessage> handler)`

  - ### Uses of Handler in io.vertx.grpc.common

    Methods in io.vertx.grpc.common with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler(Handler<GrpcError> handler)` Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`handler(Handler<T> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler(Handler<GrpcMessage> handler)` Set a handler to be notified with incoming encoded messages.

  - ### Uses of Handler in io.vertx.grpc.server

    Subinterfaces of Handler in io.vertx.grpc.server
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `GrpcServer` A gRPC server based on Vert.x HTTP server.

    Methods in io.vertx.grpc.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcServer` | GrpcServer.`callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler)` Set a call handler that handles any call made to the server.
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Deprecated. use `GrpcIoServer.callHandler(MethodDescriptor, Handler)`
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(ServiceMethod<Req,Resp> serviceMethod, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`drainHandler(Handler<Void> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`endHandler(Handler<Void> endHandler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`errorHandler(Handler<GrpcError> handler)`
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`handler(Handler<Req> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`messageHandler(Handler<GrpcMessage> handler)`

  - ### Uses of Handler in io.vertx.grpc.stub

    Methods in io.vertx.grpc.stub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | GrpcWriteStream.`drainHandler(Handler<Void> hndlr)`
    `void` | GrpcWriteStream.`end(Handler<AsyncResult<Void>> hndlr)`
    `WriteStream<T>` | GrpcWriteStream.`exceptionHandler(Handler<Throwable> hndlr)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`manyToMany(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate, Handler<Throwable> exceptionHandler)`
    `static <I,O> Future<O>` | ClientCalls.`manyToOne(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate)`
    `static <I,O> ReadStream<O>` | ClientCalls.`oneToMany(io.vertx.core.impl.ContextInternal ctx, I request, java.util.function.BiConsumer<I,io.grpc.stub.StreamObserver<O>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`oneToMany(io.vertx.core.impl.ContextInternal ctx, I request, java.util.function.BiConsumer<I,io.grpc.stub.StreamObserver<O>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `static <I,O> ReadStream<O>` | ClientCalls.`oneToMany(io.vertx.core.impl.ContextInternal ctx, I request, java.util.function.BiConsumer<I,io.grpc.stub.StreamObserver<O>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)`
    `void` | GrpcWriteStream.`write(T data, Handler<AsyncResult<Void>> hndlr)`

  - ### Uses of Handler in io.vertx.grpcio.client

    Methods in io.vertx.grpcio.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default <Req,Resp,T> Future<T>` | GrpcIoClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.

  - ### Uses of Handler in io.vertx.grpcio.server

    Subinterfaces of Handler in io.vertx.grpcio.server
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `GrpcIoServer` Extends the `GrpcServer` so it can be utilized with `MethodDescriptor`.

    Methods in io.vertx.grpcio.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp> GrpcIoServer` | GrpcIoServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the `MethodDescriptor` service method.

  - ### Uses of Handler in io.vertx.httpproxy

    Subinterfaces of Handler in io.vertx.httpproxy
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HttpProxy` Handles the HTTP reverse proxy logic between the user agent and the origin.

  - ### Uses of Handler in io.vertx.json.schema

    Methods in io.vertx.json.schema with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SchemaRouter.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser, Handler<AsyncResult<Schema>> handler)` Deprecated. Like `SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser)` but with a direct callback.

  - ### Uses of Handler in io.vertx.json.schema.common

    Methods in io.vertx.json.schema.common with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SchemaRouterImpl.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser, Handler<AsyncResult<Schema>> handler)`

  - ### Uses of Handler in io.vertx.junit5

    Methods in io.vertx.junit5 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`completing()` Deprecated. Use `VertxTestContext.succeedingThenComplete()` instead.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing()` Deprecated. Use `VertxTestContext.failingThenComplete()` or `VertxTestContext.failing(Handler)`, for example `failing(e -> checkpoint.flag())`, `failing(e -> { more testing code })`, or `failing(e -> {})`.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing(Handler<Throwable> nextHandler)` Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failingThenComplete()` Create an asynchronous result handler that expects a failure to then complete the test context.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding()` Deprecated. Use `VertxTestContext.succeedingThenComplete()` or `VertxTestContext.succeeding(Handler)`, for example `succeeding(value -> checkpoint.flag())`, `succeeding(value -> { more testing code })`, or `succeeding(value -> {})`.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding(Handler<T> nextHandler)` Create an asynchronous result handler that expects a success, and passes the value to another handler.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeedingThenComplete()` Create an asynchronous result handler that expects a success to then complete the test context.

    Methods in io.vertx.junit5 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing(Handler<Throwable> nextHandler)` Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding(Handler<T> nextHandler)` Create an asynchronous result handler that expects a success, and passes the value to another handler.

  - ### Uses of Handler in io.vertx.kafka.admin

    Methods in io.vertx.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`alterConfigs(Map<ConfigResource,Config> configs, Handler<AsyncResult<Void>> completionHandler)` Update the configuration for the specified resources with the default options
    `void` | KafkaAdminClient.`alterConsumerGroupOffsets(String groupId, Map<TopicPartition,OffsetAndMetadata> offsets, Handler<AsyncResult<Void>> completionHandler)` Alter committed offsets for a set of partitions in a consumer group.
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Create the ACL rules.
    `void` | KafkaAdminClient.`createPartitions(Map<String,NewPartitions> partitions, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new partitions in the Kafka topic
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Delete the ACL rules.
    `void` | KafkaAdminClient.`deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions, Handler<AsyncResult<Void>> completionHandler)` Delete committed offsets for a set of partitions in a consumer group.
    `void` | KafkaAdminClient.`deleteConsumerGroups(List<String> groupIds, Handler<AsyncResult<Void>> completionHandler)` Delete consumer groups from the cluster.
    `void` | KafkaAdminClient.`deleteRecords(Map<TopicPartition,org.apache.kafka.clients.admin.RecordsToDelete> recordsToDelete, Handler<AsyncResult<Map<TopicPartition,org.apache.kafka.clients.admin.DeletedRecords>>> completionHandler)` Delete records from a topic partition.
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Describe the ACL rules.
    `void` | KafkaAdminClient.`describeCluster(DescribeClusterOptions options, Handler<AsyncResult<ClusterDescription>> completionHandler)` Like `KafkaAdminClient.describeCluster(Handler)` but allows customized options.
    `void` | KafkaAdminClient.`describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)` Describe the nodes in the cluster with the default options
    `void` | KafkaAdminClient.`describeConfigs(List<ConfigResource> configResources, Handler<AsyncResult<Map<ConfigResource,Config>>> completionHandler)` Get the configuration for the specified resources with the default options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Like `KafkaAdminClient.describeConsumerGroups(List, Handler)` but allows customized options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Describe some group ids in the cluster, with the default options
    `void` | KafkaAdminClient.`describeLogDirs(List<Integer> brokers, Handler<AsyncResult<Map<Integer,Map<String,org.apache.kafka.clients.admin.LogDirDescription>>>> completionHandler)` Query the information of all log directories on the given set of brokers
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, DescribeTopicsOptions options, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Like `KafkaAdminClient.describeTopics(List, Handler)` but allows for customised otions
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Describe some topics in the cluster, with the default options.
    `default void` | KafkaAdminClient.`listConsumerGroupOffsets(String groupId, Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)` List the consumer group offsets available in the cluster.
    `void` | KafkaAdminClient.`listConsumerGroupOffsets(String groupId, ListConsumerGroupOffsetsOptions options, Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)` List the consumer group offsets available in the cluster.
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listOffsets(Map<TopicPartition,OffsetSpec> topicPartitionOffsets, Handler<AsyncResult<Map<TopicPartition,ListOffsetsResultInfo>>> completionHandler)` List the offsets available for a set of partitions.
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.kafka.client.consumer

    Methods in io.vertx.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaReadStream<K,V>` | KafkaReadStream.`assign(Set<org.apache.kafka.common.TopicPartition> partitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a set of partitions to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaReadStream<K,V>` | KafkaReadStream.`assignment(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaReadStream<K,V>` | KafkaReadStream.`batchHandler(Handler<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>> handler)` Set the handler that will be called when a new batch of records is returned from Kafka.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaReadStream.`beginningOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`beginningOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the first offset for the given partitions.
    `void` | KafkaReadStream.`beginningOffsets(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partition.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaReadStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaReadStream.`commit(Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaReadStream.`commit(Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata> offsets, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `void` | KafkaConsumer.`commit(Map<TopicPartition,OffsetAndMetadata> offsets, Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `void` | KafkaReadStream.`committed(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaReadStream<K,V>` | KafkaReadStream.`endHandler(Handler<Void> endHandler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaReadStream.`endOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)` Get the last offset for the given partitions.
    `void` | KafkaConsumer.`endOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the last offset for the given partitions.
    `void` | KafkaReadStream.`endOffsets(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaReadStream<K,V>` | KafkaReadStream.`handler(Handler<org.apache.kafka.clients.consumer.ConsumerRecord<K,V>> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `KafkaReadStream<K,V>` | KafkaReadStream.`listTopics(Handler<AsyncResult<Map<String,List<org.apache.kafka.common.PartitionInfo>>>> handler)` Get metadata about partitions for all topics that the user is authorized to view.
    `KafkaConsumer<K,V>` | KafkaConsumer.`listTopics(Handler<AsyncResult<Map<String,List<PartitionInfo>>>> handler)` Get metadata about partitions for all topics that the user is authorized to view.
    `void` | KafkaReadStream.`offsetsForTimes(Map<org.apache.kafka.common.TopicPartition,Long> topicPartitionTimestamps, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndTimestamp>>> handler)` Look up the offsets for the given partitions by timestamp.
    `void` | KafkaConsumer.`offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps, Handler<AsyncResult<Map<TopicPartition,OffsetAndTimestamp>>> handler)` Look up the offsets for the given partitions by timestamp.
    `void` | KafkaReadStream.`offsetsForTimes(org.apache.kafka.common.TopicPartition topicPartition, long timestamp, Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndTimestamp>> handler)` * Look up the offset for the given partition by timestamp.
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsAssignedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsFor(String topic, Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsRevokedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaReadStream<K,V>` | KafkaReadStream.`pause(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaReadStream.`paused(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to `KafkaReadStream.pause(Set)`.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaReadStream.`poll(java.time.Duration timeout, Handler<AsyncResult<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka.
    `void` | KafkaConsumer.`poll(java.time.Duration timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka.
    `void` | KafkaReadStream.`position(org.apache.kafka.common.TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaReadStream<K,V>` | KafkaReadStream.`resume(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seek(org.apache.kafka.common.TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seekToBeginning(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seekToEnd(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscribe(Pattern pattern, Handler<AsyncResult<Void>> completionHandler)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Pattern pattern, Handler<AsyncResult<Void>> completionHandler)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaReadStream<K,V>` | KafkaReadStream.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.kafka.client.producer

    Methods in io.vertx.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaProducer<K,V>` | KafkaProducer.`abortTransaction(Handler<AsyncResult<Void>> handler)` Aborts the ongoing transaction.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`abortTransaction(Handler<AsyncResult<Void>> handler)` Aborts the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`beginTransaction(Handler<AsyncResult<Void>> handler)` Starts a new kafka transaction.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`beginTransaction(Handler<AsyncResult<Void>> handler)` Starts a new kafka transaction.
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaWriteStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaWriteStream.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `KafkaProducer<K,V>` | KafkaProducer.`commitTransaction(Handler<AsyncResult<Void>> handler)` Commits the ongoing transaction.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`commitTransaction(Handler<AsyncResult<Void>> handler)` Commits the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`drainHandler(Handler<Void> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<AsyncResult<Void>> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`flush(Handler<AsyncResult<Void>> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`initTransactions(Handler<AsyncResult<Void>> handler)` Initializes the underlying kafka transactional producer.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`initTransactions(Handler<AsyncResult<Void>> handler)` Initializes the underlying kafka transactional producer.
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`partitionsFor(String topic, Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`send(org.apache.kafka.clients.producer.ProducerRecord<K,V> record, Handler<AsyncResult<org.apache.kafka.clients.producer.RecordMetadata>> handler)` Asynchronously write a record to a topic

  - ### Uses of Handler in io.vertx.lang.reactivex

    Methods in io.vertx.lang.reactivex that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

    Methods in io.vertx.lang.reactivex with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

  - ### Uses of Handler in io.vertx.lang.rxjava

    Methods in io.vertx.lang.rxjava that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

    Methods in io.vertx.lang.rxjava with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

  - ### Uses of Handler in io.vertx.lang.rxjava3

    Methods in io.vertx.lang.rxjava3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

    Methods in io.vertx.lang.rxjava3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <CORE,REACTIVE> Handler<CORE>` | Helper.`convertHandler(Handler<REACTIVE> rxHandler, java.util.function.Function<CORE,REACTIVE> mapper)` Convert a handler for a generated reactive type to a handler for the corresponding core type.

  - ### Uses of Handler in io.vertx.micrometer

    Methods in io.vertx.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(io.micrometer.prometheus.PrometheusMeterRegistry registry)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.mqtt

    Methods in io.vertx.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)` Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)` Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(List<String> topics, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topics
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.mssqlclient

    Methods in io.vertx.mssqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `static void` | MSSQLConnection.`connect(Vertx vertx, MSSQLConnectOptions connectOptions, Handler<AsyncResult<MSSQLConnection>> handler)` Create a connection to SQL Server with the given `connectOptions`.
    `static void` | MSSQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MSSQLConnection>> handler)` Like `MSSQLConnection.connect(Vertx, MSSQLConnectOptions, Handler)` with options built from `connectionUri`.
    `MSSQLPool` | MSSQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `MSSQLConnection` | MSSQLConnection.`infoHandler(Handler<MSSQLInfo> handler)` Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.

  - ### Uses of Handler in io.vertx.mysqlclient

    Methods in io.vertx.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static SqlClient` | MySQLBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(Vertx, MySQLConnectOptions, Handler)` with options built from `connectionUri`.
    `MySQLPool` | MySQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | MySQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.pgclient

    Methods in io.vertx.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static SqlClient` | PgBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(Vertx, PgConnectOptions, Handler)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(Vertx, PgConnectOptions, Handler)` with options build from `connectionUri`.
    `PgPool` | PgPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `PgConnection` | PgConnection.`noticeHandler(Handler<PgNotice> handler)` Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.

  - ### Uses of Handler in io.vertx.pgclient.pubsub

    Methods in io.vertx.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | PgSubscriber.`close(Handler<AsyncResult<Void>> handler)` Close the subscriber, the retry policy will not be invoked.
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.rabbitmq

    Methods in io.vertx.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)` Add a Confirm Listener to the channel.
    `void` | RabbitMQClient.`addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)` Set a callback to be called whenever a new connection is established.
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler)` Acknowledge one or several received messages.
    `default void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Future<Void>` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `default void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `default void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQPublisher.`publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Long>> resultHandler)` Publish a message and complete when publish confirm has returned.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`restartConnect(int attempts, Handler<AsyncResult<Void>> resultHandler)` restart the rabbitMQ connect.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.reactivex

    Methods in io.vertx.reactivex with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> SingleObserver<T>` | SingleHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> CompletableObserver` | CompletableHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> MaybeObserver<T>` | MaybeHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.

    Method parameters in io.vertx.reactivex with type arguments of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Completable` | CompletableHelper.`toCompletable(java.util.function.Consumer<Handler<AsyncResult<Void>>> handler)` Returns a `Completable` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Maybe<T>` | MaybeHelper.`toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)` Returns a `Maybe` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Single<T>` | SingleHelper.`toSingle(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)` Returns a `Single` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.

  - ### Uses of Handler in io.vertx.reactivex.amqp

    Methods in io.vertx.reactivex.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | AmqpSender.`end(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AmqpSender.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.
    `void` | AmqpSender.`write(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.cassandra

    Methods in io.vertx.reactivex.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.cassandra.ResultSet>>)` or .
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `CassandraClient` | CassandraClient.`execute(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `void` | ResultSet.`fetchNextPage(Handler<AsyncResult<ResultSet>> handler)` Like `ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.cassandra.ResultSet>>)` but with a direct callback.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)`
    `void` | CassandraClient.`metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)` Get for the session.
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst, Handler<AsyncResult<Void>> handler)`
    `CassandraClient` | CassandraClient.`prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided a .
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

  - ### Uses of Handler in io.vertx.reactivex.circuitbreaker

    Methods in io.vertx.reactivex.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to close.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.reactivex.core.Promise<T>, io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to open.
    `<T> Single<T>` | CircuitBreaker.`rxExecute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.

  - ### Uses of Handler in io.vertx.reactivex.config

    Methods in io.vertx.reactivex.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> handler)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.reactivex.core

    Methods in io.vertx.reactivex.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxBuilder.`buildClustered(Handler<AsyncResult<Vertx>> handler)` Creates a clustered instance.
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)` Deprecated.
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
    `<T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)` Deprecated.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Deprecated.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setPeriodic(long initialDelay, long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.reactivex.core.datagram

    Methods in io.vertx.reactivex.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address and notifies the once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)` Deprecated.
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.reactivex.core.dns

    Methods in io.vertx.reactivex.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | DnsClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.reactivex.core.eventbus

    Methods in io.vertx.reactivex.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(MessageConsumerOptions options, Handler<Message<T>> handler)` Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(io.vertx.core.eventbus.MessageConsumerOptions)` but the address won't be propagated across the cluster.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like `Message.replyAndRequest(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.eventbus.Message<R>>>)` but specifying `options` that can be used to configure the delivery.
    `<R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.request(java.lang.String, java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.eventbus.Message<T>>>)` but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `void` | MessageProducer.`write(T body, Handler<AsyncResult<Void>> handler)` Write a message to the event-bus, either sending or publishing.

  - ### Uses of Handler in io.vertx.reactivex.core.file

    Methods in io.vertx.reactivex.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deprecated.
    `FileSystem` | FileSystem.`deleteRecursive(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `void` | AsyncFile.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `void` | AsyncFileLock.`isValid(Handler<AsyncResult<Boolean>> handler)` Like `AsyncFileLock.isValid(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but the `handler` will be called when the operation completes or if an error occurs.
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `void` | AsyncFile.`lock(Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.AsyncFileLock>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `void` | AsyncFile.`lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.AsyncFileLock>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `void` | AsyncFileLock.`release(Handler<AsyncResult<Void>> handler)` Like `AsyncFileLock.release(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the `handler` will be called when the operation completes or if an error occurs.
    `void` | AsyncFile.`size(Handler<AsyncResult<Long>> handler)` Like `AsyncFile.size(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `void` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.reactivex.core.http

    Methods in io.vertx.reactivex.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpClientResponse` | HttpClientResponse.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | WebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | ServerWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | HttpClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`closeHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `void` | ClientWebSocket.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | WebSocketClient.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | ClientWebSocket.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and port.
    `void` | WebSocketClient.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `void` | ClientWebSocket.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket to the host and relative request URI and default port.
    `void` | WebSocketClient.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port and specified host and relative request URI.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a Continue handler has been set using this method, then the `handler` will be called.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler(Handler<MultiMap> handler)` If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `void` | WebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpServerRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerRequest.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | ServerWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `ClientWebSocket` | ClientWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ClientWebSocket` | ClientWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ClientWebSocket` | ClientWebSocket.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler(Handler<HttpServerRequest> handler)` Set a `handler` for handling invalid requests.
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ClientWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`pongHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with no headers.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort authority, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `void` | HttpClient.`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` | HttpClient.`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` | HttpClient.`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` | HttpClient.`request(RequestOptions options, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpClientRequest` | HttpClientRequest.`response(Handler<AsyncResult<HttpClientResponse>> handler)` Set a callback for the associated `HttpClientResponse`.
    `void` | HttpClientRequest.`send(Buffer body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a buffer `body`.
    `void` | HttpServerResponse.`send(Buffer body, Handler<AsyncResult<Void>> handler)` Send the request with a buffer `body`.
    `void` | HttpClientRequest.`send(Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a stream `body`.
    `void` | HttpServerResponse.`send(Flowable<Buffer> body, Handler<AsyncResult<Void>> handler)` Send the request with a stream `body`.
    `void` | HttpClientRequest.`send(Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with an empty body.
    `void` | HttpServerResponse.`send(Handler<AsyncResult<Void>> handler)` Send the request with an empty body.
    `void` | HttpClientRequest.`send(ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a stream `body`.
    `void` | HttpServerResponse.`send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler)` Send the request with a stream `body`.
    `void` | HttpClientRequest.`send(String body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a string `body`.
    `void` | HttpServerResponse.`send(String body, Handler<AsyncResult<Void>> handler)` Send the request with a string `body`.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<AsyncResult<Void>> completionHandler)` Like `HttpClientRequest.sendHead(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Deprecated.
    `void` | ServerWebSocket.`setHandshake(Single<Integer> future, Handler<AsyncResult<Integer>> handler)` Deprecated.
    `void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Shutdown a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Deprecated.
    `void` | HttpConnection.`shutdown(long timeout, TimeUnit unit, Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `WebSocketBase` | WebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler(Handler<String> handler)`
    `WebSocketBase` | ServerWebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `void` | HttpServerRequest.`toNetSocket(Handler<AsyncResult<NetSocket>> handler)` Establish a TCP tunnel with the client.
    `void` | HttpServerRequest.`toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)` Upgrade the connection of the current request to a WebSocket.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `void` | WebSocketClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | WebSocketClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler(Handler<ServerWebSocketHandshake> handler)` Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `void` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`writeEarlyHints(MultiMap headers, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.writeEarlyHints(io.vertx.reactivex.core.MultiMap, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(io.vertx.reactivex.core.http.WebSocketFrame, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.core.net

    Methods in io.vertx.reactivex.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be notified when close is complete.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `void` | NetClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `void` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the message has been written or failed to be written.
    `void` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.core.parsetools

    Methods in io.vertx.reactivex.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.reactivex.core.shareddata

    Methods in io.vertx.reactivex.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`keys(Handler<AsyncResult<Set<K>>> resultHandler)` Get the keys of the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replace(K k, V v, long ttl, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, long ttl, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map
    `void` | AsyncMap.`values(Handler<AsyncResult<List<V>>> resultHandler)` Get the values of the map, asynchronously.

  - ### Uses of Handler in io.vertx.reactivex.core.streams

    Methods in io.vertx.reactivex.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `void` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.db2client

    Methods in io.vertx.reactivex.db2client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static SqlClient` | DB2Builder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler(Handler<Void> handler)`
    `static void` | DB2Connection.`connect(Vertx vertx, DB2ConnectOptions connectOptions, Handler<AsyncResult<DB2Connection>> handler)` Create a connection to DB2 server with the given `connectOptions`.
    `static void` | DB2Connection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<DB2Connection>> handler)` Like `DB2Connection.connect(io.vertx.reactivex.core.Vertx, io.vertx.db2client.DB2ConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.db2client.DB2Connection>>)` with options build from `connectionUri`.
    `DB2Pool` | DB2Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`exceptionHandler(Handler<Throwable> handler)`
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | DB2Builder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.ext.auth

    Methods in io.vertx.reactivex.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `User` | User.`isAuthorized(Authorization authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.authentication

    Methods in io.vertx.reactivex.ext.auth.authentication with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthenticationProvider.`authenticate(Credentials credentials, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `void` | AuthenticationProvider.`authenticate(JsonObject credentials, Handler<AsyncResult<User>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.authorization

    Methods in io.vertx.reactivex.ext.auth.authorization with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthorizationProvider.`getAuthorizations(User user, Handler<AsyncResult<Void>> handler)` Updates the user with the set of authorizations.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.jdbc

    Methods in io.vertx.reactivex.ext.auth.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JDBCUserUtil` | JDBCUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.mongo

    Methods in io.vertx.reactivex.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoUserUtil` | MongoUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `MongoUserUtil` | MongoUserUtil.`createUser(String username, String password, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `MongoUserUtil` | MongoUserUtil.`createUserRolesAndPermissions(String username, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a user role into a database.
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.oauth2

    Methods in io.vertx.reactivex.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`jWKSet(Handler<AsyncResult<Void>> handler)` Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler(Handler<String> handler)` Handled to be called when a key (mentioned on a JWT) is missing from the current config.
    `OAuth2Auth` | OAuth2Auth.`refresh(User user, Handler<AsyncResult<User>> handler)` Refresh the current User (access token).
    `OAuth2Auth` | OAuth2Auth.`revoke(User user, Handler<AsyncResult<Void>> handler)` Revoke an obtained access token.
    `OAuth2Auth` | OAuth2Auth.`revoke(User user, String tokenType, Handler<AsyncResult<Void>> handler)` Revoke an obtained access or refresh token.
    `OAuth2Auth` | OAuth2Auth.`userInfo(User user, Handler<AsyncResult<JsonObject>> handler)` Retrieve profile information and other attributes for a logged-in end-user.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.oauth2.providers

    Methods in io.vertx.reactivex.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AmazonCognitoAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | IBMCloudAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.sqlclient

    Methods in io.vertx.reactivex.ext.auth.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SqlUserUtil` | SqlUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `SqlUserUtil` | SqlUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Insert a role permission into a database.
    `SqlUserUtil` | SqlUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `SqlUserUtil` | SqlUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Insert a user role into a database.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.webauthn

    Methods in io.vertx.reactivex.ext.auth.webauthn with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebAuthn` | WebAuthn.`createCredentialsOptions(JsonObject user, Handler<AsyncResult<JsonObject>> handler)` Gets a challenge and any other parameters for the `navigator.credentials.create()` call.
    `MetaDataService` | MetaDataService.`fetchTOC(Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
    `MetaDataService` | MetaDataService.`fetchTOC(String url, Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
    `WebAuthn` | WebAuthn.`getCredentialsOptions(String name, Handler<AsyncResult<JsonObject>> handler)` Creates an assertion challenge and any other parameters for the `navigator.credentials.get()` call.

  - ### Uses of Handler in io.vertx.reactivex.ext.consul

    Methods in io.vertx.reactivex.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String accessorId, CloneAclTokenOptions cloneAclToken, Handler<AsyncResult<AclToken>> resultHandler)` Clones an existing ACL token
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `ConsulClient` | ConsulClient.`createAclPolicy(AclPolicy policy, Handler<AsyncResult<String>> resultHandler)` Creates a new ACL policy
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Create an Acl token
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`deleteAclToken(String accessorId, Handler<AsyncResult<Boolean>> resultHandler)` Deletes an ACL token
    `ConsulClient` | ConsulClient.`deletePolicy(String id, Handler<AsyncResult<Boolean>> resultHandler)` This endpoint deletes an ACL policy
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulClient` | ConsulClient.`deregisterCatalogService(String nodeId, String serviceId, Handler<AsyncResult<Void>> resultHandler)` Deregister entities from the node or deregister the node itself.
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`getAclPolicies(Handler<AsyncResult<List<AclPolicy>>> resultHandler)` This endpoint lists all the ACL policies.
    `ConsulClient` | ConsulClient.`getAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthNodesWithOptions(String node, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks specific to the node provided on the path.
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`readAclToken(String accessorId, Handler<AsyncResult<AclToken>> resultHandler)` Reads an ACL token with the given Accessor ID
    `ConsulClient` | ConsulClient.`readPolicy(String id, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given ID
    `ConsulClient` | ConsulClient.`readPolicyByName(String name, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given name
    `ConsulClient` | ConsulClient.`registerCatalogService(Node nodeOptions, ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Register node with external service
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`updateAclToken(String accessorId, AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Update an existing Acl token
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updatePolicy(String id, AclPolicy policy, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint updates an existing ACL policy
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".

  - ### Uses of Handler in io.vertx.reactivex.ext.eventbus.bridge.tcp

    Methods in io.vertx.reactivex.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.reactivex.ext.healthchecks

    Methods in io.vertx.reactivex.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HealthChecks.`checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedures.
    `void` | HealthChecks.`checkStatus(String name, Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.reactivex.ext.jdbc

    Methods in io.vertx.reactivex.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.reactivex.ext.mail

    Methods in io.vertx.reactivex.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MailClient.`close(Handler<AsyncResult<Void>> closedHandler)` Close the MailClient
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.reactivex.ext.mongo

    Methods in io.vertx.reactivex.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `void` | MongoClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release its resources
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`countWithOptions(String collection, JsonObject query, CountOptions countOptions, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | MongoClient.`createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions, Handler<AsyncResult<Void>> resultHandler)` Create a new collection with options
    `MongoClient` | MongoClient.`createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createGridFsBucketService(String bucketName, Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoClient` | MongoClient.`createIndexes(String collection, List<IndexModel> indexes, Handler<AsyncResult<Void>> resultHandler)` creates an indexes
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoGridFsClient` | MongoGridFsClient.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes a file by it's ID
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadFile(String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileAs(String fileName, String newFileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file and gives it a new name.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileByID(String id, String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file using the ID generated by GridFs.
    `MongoGridFsClient` | MongoGridFsClient.`drop(Handler<AsyncResult<Void>> resultHandler)` Drops the entire file bucket with all of its contents
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoGridFsClient` | MongoGridFsClient.`findAllIds(Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids in the bucket
    `MongoGridFsClient` | MongoGridFsClient.`findIds(JsonObject query, Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids that match a query.
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonArray update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Flowable<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Flowable<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadFile(String fileName, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs
    `MongoGridFsClient` | MongoGridFsClient.`uploadFileWithOptions(String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs with options

  - ### Uses of Handler in io.vertx.reactivex.ext.shell

    Methods in io.vertx.reactivex.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.command

    Methods in io.vertx.reactivex.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.system

    Methods in io.vertx.reactivex.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.term

    Methods in io.vertx.reactivex.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Bind the term server, the `TermServer.termHandler(io.vertx.core.Handler<io.vertx.reactivex.ext.shell.term.Term>)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.reactivex.ext.sql

    Methods in io.vertx.reactivex.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.reactivex.ext.stomp

    Methods in io.vertx.reactivex.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the able to manage web socket connections.

    Methods in io.vertx.reactivex.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.reactivex.ext.unit

    Methods in io.vertx.reactivex.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.reactivex.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | Async.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | TestCompletion.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.reactivex.ext.unit.collect

    Methods in io.vertx.reactivex.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.reactivex.ext.unit.report

    Methods in io.vertx.reactivex.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Handler in io.vertx.reactivex.ext.web

    Methods in io.vertx.reactivex.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.reactivex.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `RoutingContext` | RoutingContext.`end(Buffer buffer, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `RoutingContext` | RoutingContext.`end(Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `RoutingContext` | RoutingContext.`end(String chunk, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `void` | UserContext.`impersonate(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`impersonate(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `RoutingContext` | RoutingContext.`json(Object json, Handler<AsyncResult<Void>> handler)` See `RoutingContext.json(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `void` | UserContext.`logout(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`logout(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.
    `RoutingContext` | RoutingContext.`redirect(String url, Handler<AsyncResult<Void>> handler)` See `RoutingContext.redirect(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `void` | UserContext.`restore(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`restore(String redirectUri, Handler<AsyncResult<Void>> callback)`

  - ### Uses of Handler in io.vertx.reactivex.ext.web.api.contract

    Methods in io.vertx.reactivex.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.reactivex.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.api.contract.openapi3

    Methods in io.vertx.reactivex.ext.web.api.contract.openapi3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | OpenAPI3RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.reactivex.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Deprecated.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.client

    Methods in io.vertx.reactivex.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendForm(MultiMap body, String charset, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(Flowable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | WebClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | WebClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).

  - ### Uses of Handler in io.vertx.reactivex.ext.web.common.template

    Methods in io.vertx.reactivex.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler

    Methods in io.vertx.reactivex.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `SessionHandler` | SessionHandler.`flush(RoutingContext ctx, boolean ignoreStatus, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `SessionHandler` | SessionHandler.`flush(RoutingContext ctx, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `SessionHandler` | SessionHandler.`setUser(RoutingContext context, User user, Handler<AsyncResult<Void>> handler)` Set the user for the session

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler.graphql

    Methods in io.vertx.reactivex.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)` Deprecated.
    `GraphQLHandler` | GraphQLHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)` Deprecated.
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler.graphql.ws

    Methods in io.vertx.reactivex.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandler` | GraphQLWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`messageHandler(Handler<Message> messageHandler)` Deprecated.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit(Handler<ConnectionInitEvent> connectionInitHandler)` Customize the connection init .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage(Handler<Message> messageHandler)` Customize the message .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd(Handler<ServerWebSocket> endHandler)` Customize the end .

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler.sockjs

    Methods in io.vertx.reactivex.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `Router` | SockJSHandler.`bridge(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler(Handler<Void> closeHandler)`
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `void` | SockJSSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | SockJSSocket.`end(Handler<AsyncResult<Void>> handler)` Same as `SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.ext.web.openapi

    Methods in io.vertx.reactivex.ext.web.openapi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | RouterBuilder.`create(Vertx vertx, String url, Handler<AsyncResult<RouterBuilder>> handler)` Like
    `static void` | RouterBuilder.`create(Vertx vertx, String url, OpenAPILoaderOptions options, Handler<AsyncResult<RouterBuilder>> handler)` Like
    `Operation` | Operation.`failureHandler(Handler<RoutingContext> handler)` Mount a failure handler for this operation
    `Operation` | Operation.`handler(Handler<RoutingContext> handler)` Mount an handler for this operation
    `RouterBuilder` | RouterBuilder.`rootHandler(Handler<RoutingContext> rootHandler)` Add global handler to be applied prior to being generated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.openapi.router

    Methods in io.vertx.reactivex.ext.web.openapi.router with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPIRoute` | OpenAPIRoute.`addFailureHandler(Handler<RoutingContext> handler)` Adds a failure handler for this route
    `OpenAPIRoute` | OpenAPIRoute.`addHandler(Handler<RoutingContext> handler)` Adds a handler for this route which is executed after the security and validation handlers defined in the contract
    `RouterBuilder` | RouterBuilder.`rootHandler(Handler<RoutingContext> rootHandler)` Add global handler to be applied prior to being generated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.sstore

    Methods in io.vertx.reactivex.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SessionStore` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `SessionStore` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `SessionStore` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `SessionStore` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `SessionStore` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.reactivex.grpc.client

    Methods in io.vertx.reactivex.grpc.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Deprecated.
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>,Single<T>> resultFn)` Deprecated.
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`drainHandler(Handler<Void> handler)`
    `void` | GrpcClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcClientRequest.`end(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`endHandler(Handler<Void> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`errorHandler(Handler<GrpcError> handler)`
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`handler(Handler<Resp> handler)`
    `GrpcReadStream<Resp>` | GrpcClientResponse.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`messageHandler(Handler<GrpcMessage> handler)`
    `void` | GrpcClientResponse.`pipeTo(WriteStream<Resp> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<Req,Resp,T> Single<T>` | GrpcClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Deprecated.
    `<Req,Resp,T> Single<T>` | GrpcClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>,Single<T>> resultFn)` Deprecated.
    `void` | GrpcClientRequest.`write(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.grpc.common

    Methods in io.vertx.reactivex.grpc.common with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler(Handler<Void> handler)`
    `void` | GrpcWriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcWriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler(Handler<GrpcError> handler)` Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`handler(Handler<T> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler(Handler<GrpcMessage> handler)` Set a handler to be notified with incoming encoded messages.
    `void` | GrpcReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcWriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.grpc.server

    Methods in io.vertx.reactivex.grpc.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcServer` | GrpcServer.`callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler)` Set a call handler that handles any call made to the server.
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Deprecated.
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(ServiceMethod<Req,Resp> serviceMethod, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`drainHandler(Handler<Void> handler)`
    `void` | GrpcServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcServerResponse.`end(Resp data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`endHandler(Handler<Void> endHandler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`errorHandler(Handler<GrpcError> handler)`
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`handler(Handler<Req> handler)`
    `GrpcReadStream<Req>` | GrpcServerRequest.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`messageHandler(Handler<GrpcMessage> handler)`
    `void` | GrpcServerRequest.`pipeTo(WriteStream<Req> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcServerResponse.`write(Resp data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.grpcio.client

    Methods in io.vertx.reactivex.grpcio.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcIoClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `<Req,Resp,T> Future<T>` | GrpcIoClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>,Single<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `<Req,Resp,T> Single<T>` | GrpcIoClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `<Req,Resp,T> Single<T>` | GrpcIoClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>,Single<T>> resultFn)` Call the `service` gRPC service hosted by `server`.

  - ### Uses of Handler in io.vertx.reactivex.grpcio.server

    Methods in io.vertx.reactivex.grpcio.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp> GrpcIoServer` | GrpcIoServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the service method.

  - ### Uses of Handler in io.vertx.reactivex.json.schema

    Methods in io.vertx.reactivex.json.schema with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SchemaRouter.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser, Handler<AsyncResult<Schema>> handler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.kafka.admin

    Methods in io.vertx.reactivex.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Create the ACL rules.
    `void` | KafkaAdminClient.`createPartitions(Map<String,NewPartitions> partitions, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new partitions in the Kafka topic
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Delete the ACL rules.
    `void` | KafkaAdminClient.`deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions, Handler<AsyncResult<Void>> completionHandler)` Delete committed offsets for a set of partitions in a consumer group.
    `void` | KafkaAdminClient.`deleteConsumerGroups(List<String> groupIds, Handler<AsyncResult<Void>> completionHandler)` Delete consumer groups from the cluster.
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Describe the ACL rules.
    `void` | KafkaAdminClient.`describeCluster(DescribeClusterOptions options, Handler<AsyncResult<ClusterDescription>> completionHandler)` Like `KafkaAdminClient.describeCluster(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.kafka.admin.ClusterDescription>>)` but allows customized options.
    `void` | KafkaAdminClient.`describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)` Describe the nodes in the cluster with the default options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Like `KafkaAdminClient.describeConsumerGroups(java.util.List<java.lang.String>, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.Map<java.lang.String, io.vertx.kafka.admin.ConsumerGroupDescription>>>)` but allows customized options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Describe some group ids in the cluster, with the default options
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, DescribeTopicsOptions options, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Like `KafkaAdminClient.describeTopics(java.util.List<java.lang.String>, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.Map<java.lang.String, io.vertx.kafka.admin.TopicDescription>>>)` but allows for customised otions
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Describe some topics in the cluster, with the default options.
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.reactivex.kafka.client.consumer

    Methods in io.vertx.reactivex.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | KafkaConsumer.`poll(java.time.Duration timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka.
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.reactivex.kafka.client.producer

    Methods in io.vertx.reactivex.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaProducer<K,V>` | KafkaProducer.`abortTransaction(Handler<AsyncResult<Void>> handler)` Aborts the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`beginTransaction(Handler<AsyncResult<Void>> handler)` Starts a new kafka transaction.
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `KafkaProducer<K,V>` | KafkaProducer.`commitTransaction(Handler<AsyncResult<Void>> handler)` Commits the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `void` | KafkaProducer.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | KafkaProducer.`end(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<AsyncResult<Void>> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`initTransactions(Handler<AsyncResult<Void>> handler)` Initializes the underlying kafka transactional producer.
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `void` | KafkaProducer.`write(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.micrometer

    Methods in io.vertx.reactivex.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(io.micrometer.prometheus.PrometheusMeterRegistry registry)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.reactivex.mqtt

    Methods in io.vertx.reactivex.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)` Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)` Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(List<String> topics, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topics
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.reactivex.mssqlclient

    Methods in io.vertx.reactivex.mssqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MSSQLConnection.`connect(Vertx vertx, MSSQLConnectOptions connectOptions, Handler<AsyncResult<MSSQLConnection>> handler)` Create a connection to SQL Server with the given `connectOptions`.
    `static void` | MSSQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MSSQLConnection>> handler)` Like `MSSQLConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.mssqlclient.MSSQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.mssqlclient.MSSQLConnection>>)` with options built from `connectionUri`.
    `MSSQLPool` | MSSQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MSSQLConnection` | MSSQLConnection.`infoHandler(Handler<MSSQLInfo> handler)` Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.mysqlclient

    Methods in io.vertx.reactivex.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static SqlClient` | MySQLBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.mysqlclient.MySQLConnection>>)` with options built from `connectionUri`.
    `MySQLPool` | MySQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | MySQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.reactivex.oracleclient

    Methods in io.vertx.reactivex.oracleclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OracleConnection` | OracleConnection.`closeHandler(Handler<Void> handler)`
    `static void` | OracleConnection.`connect(Vertx vertx, io.vertx.oracleclient.OracleConnectOptions connectOptions, Handler<AsyncResult<OracleConnection>> handler)` Create a connection to Oracle with the given `connectOptions`.
    `OraclePool` | OraclePool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `OracleConnection` | OracleConnection.`exceptionHandler(Handler<Throwable> handler)`
    `static Pool` | OracleBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `OracleConnection` | OracleConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.pgclient

    Methods in io.vertx.reactivex.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static SqlClient` | PgBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)`
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.pgclient.PgConnection>>)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.pgclient.PgConnection>>)` with options build from `connectionUri`.
    `PgPool` | PgPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)`
    `PgConnection` | PgConnection.`noticeHandler(Handler<PgNotice> handler)` Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.pgclient.pubsub

    Methods in io.vertx.reactivex.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | PgSubscriber.`close(Handler<AsyncResult<Void>> handler)` Close the subscriber, the retry policy will not be invoked.
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.reactivex.rabbitmq

    Methods in io.vertx.reactivex.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)` Add a Confirm Listener to the channel.
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler)` Acknowledge one or several received messages.
    `void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQPublisher.`publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Long>> resultHandler)` Publish a message and complete when publish confirm has returned.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`restartConnect(int attempts, Handler<AsyncResult<Void>> resultHandler)` restart the rabbitMQ connect.
    `Completable` | RabbitMQClient.`rxBasicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.reactivex.redis.client

    Methods in io.vertx.reactivex.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Access List Control commands.
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Append a value to a key.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Sent by cluster clients after an -ASK redirect.
    `RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Authenticate to the server.
    `Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisAPI` | RedisAPI.`bfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.ADD.
    `RedisAPI` | RedisAPI.`bfCard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.CARD.
    `RedisAPI` | RedisAPI.`bfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.DEBUG.
    `RedisAPI` | RedisAPI.`bfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.EXISTS.
    `RedisAPI` | RedisAPI.`bfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INFO.
    `RedisAPI` | RedisAPI.`bfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INSERT.
    `RedisAPI` | RedisAPI.`bfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.LOADCHUNK.
    `RedisAPI` | RedisAPI.`bfMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MADD.
    `RedisAPI` | RedisAPI.`bfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MEXISTS.
    `RedisAPI` | RedisAPI.`bfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.RESERVE.
    `RedisAPI` | RedisAPI.`bfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.SCANDUMP.
    `RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Asynchronously rewrite the append-only file.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Asynchronously save the dataset to disk.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Count set bits in a string.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Perform bitwise operations between strings.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Find first bit set or clear in a string.
    `RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list, or block until one is available.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first element in a list, or block until one is available.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last element in a list, or block until one is available.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set or block until one is available.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | RedisAPI.`cfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADD.
    `RedisAPI` | RedisAPI.`cfAddnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADDNX.
    `RedisAPI` | RedisAPI.`cfCompact(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COMPACT.
    `RedisAPI` | RedisAPI.`cfCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COUNT.
    `RedisAPI` | RedisAPI.`cfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEBUG.
    `RedisAPI` | RedisAPI.`cfDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEL.
    `RedisAPI` | RedisAPI.`cfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.EXISTS.
    `RedisAPI` | RedisAPI.`cfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INFO.
    `RedisAPI` | RedisAPI.`cfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERT.
    `RedisAPI` | RedisAPI.`cfInsertnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERTNX.
    `RedisAPI` | RedisAPI.`cfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.LOADCHUNK.
    `RedisAPI` | RedisAPI.`cfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.MEXISTS.
    `RedisAPI` | RedisAPI.`cfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.RESERVE.
    `RedisAPI` | RedisAPI.`cfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.SCANDUMP.
    `RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` A container for client connection commands.
    `RedisConnection` | RedisConnection.`close(Handler<AsyncResult<Void>> onClose)` Closes the connection or returns to the pool.
    `RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` A container for cluster commands.
    `RedisAPI` | RedisAPI.`cmsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INCRBY.
    `RedisAPI` | RedisAPI.`cmsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INFO.
    `RedisAPI` | RedisAPI.`cmsInitbydim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYDIM.
    `RedisAPI` | RedisAPI.`cmsInitbyprob(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYPROB.
    `RedisAPI` | RedisAPI.`cmsMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.MERGE.
    `RedisAPI` | RedisAPI.`cmsQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.QUERY.
    `RedisAPI` | RedisAPI.`command(List<String> args, Handler<AsyncResult<Response>> handler)` Get array of Redis command details.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` A container for server configuration commands.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Copy a key.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Return the number of keys in the selected database.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` A container for debugging commands.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by one.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by the given number.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Discard all commands issued after MULTI.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Echo the given string.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)`
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)`
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Execute all commands issued after MULTI.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Determine if a key exists.
    `RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in seconds.
    `RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp.
    `RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key.
    `RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Start a coordinated failover between this server and one of its replicas.
    `RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a function.
    `RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a read-only function.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from all databases.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from the current database.
    `RedisAPI` | RedisAPI.`ftAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ADD.
    `RedisAPI` | RedisAPI.`ftAggregate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.AGGREGATE.
    `RedisAPI` | RedisAPI.`ftAliasadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASADD.
    `RedisAPI` | RedisAPI.`ftAliasaddifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASADDIFNX.
    `RedisAPI` | RedisAPI.`ftAliasdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASDEL.
    `RedisAPI` | RedisAPI.`ftAliasdelifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASDELIFX.
    `RedisAPI` | RedisAPI.`ftAliasupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASUPDATE.
    `RedisAPI` | RedisAPI.`ftAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALTER.
    `RedisAPI` | RedisAPI.`ftAlterifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALTERIFNX.
    `RedisAPI` | RedisAPI.`ftConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CONFIG.
    `RedisAPI` | RedisAPI.`ftCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CREATE.
    `RedisAPI` | RedisAPI.`ftCreateifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._CREATEIFNX.
    `RedisAPI` | RedisAPI.`ftCursor(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CURSOR.
    `RedisAPI` | RedisAPI.`ftDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEBUG.
    `RedisAPI` | RedisAPI.`ftDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEL.
    `RedisAPI` | RedisAPI.`ftDictadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTADD.
    `RedisAPI` | RedisAPI.`ftDictdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDEL.
    `RedisAPI` | RedisAPI.`ftDictdump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDUMP.
    `RedisAPI` | RedisAPI.`ftDrop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROP.
    `RedisAPI` | RedisAPI.`ftDropifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPIFX.
    `RedisAPI` | RedisAPI.`ftDropindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROPINDEX.
    `RedisAPI` | RedisAPI.`ftDropindexifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPINDEXIFX.
    `RedisAPI` | RedisAPI.`ftExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAIN.
    `RedisAPI` | RedisAPI.`ftExplaincli(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAINCLI.
    `RedisAPI` | RedisAPI.`ftGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.GET.
    `RedisAPI` | RedisAPI.`ftInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.INFO.
    `RedisAPI` | RedisAPI.`ftList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._LIST.
    `RedisAPI` | RedisAPI.`ftMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.MGET.
    `RedisAPI` | RedisAPI.`ftProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.PROFILE.
    `RedisAPI` | RedisAPI.`ftSafeadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SAFEADD.
    `RedisAPI` | RedisAPI.`ftSearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SEARCH.
    `RedisAPI` | RedisAPI.`ftSpellcheck(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SPELLCHECK.
    `RedisAPI` | RedisAPI.`ftSugadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGADD.
    `RedisAPI` | RedisAPI.`ftSugdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGDEL.
    `RedisAPI` | RedisAPI.`ftSugget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGGET.
    `RedisAPI` | RedisAPI.`ftSuglen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGLEN.
    `RedisAPI` | RedisAPI.`ftSynadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNADD.
    `RedisAPI` | RedisAPI.`ftSyndump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNDUMP.
    `RedisAPI` | RedisAPI.`ftSynupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNUPDATE.
    `RedisAPI` | RedisAPI.`ftTagvals(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.TAGVALS.
    `RedisAPI` | RedisAPI.`function(List<String> args, Handler<AsyncResult<Response>> handler)` A container for function commands.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the distance between two members of a geospatial index.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Returns members of a geospatial index as standard geohash strings.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Returns longitude and latitude of members of a geospatial index.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUSBYMEMBER.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUS.
    `RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Returns the bit value at offset in the string value stored at key.
    `RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key and delete the key.
    `RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Get the value of a key and optionally set its expiration.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the string value of a key and return its old value.
    `RedisAPI` | RedisAPI.`graphBulk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.BULK.
    `RedisAPI` | RedisAPI.`graphConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.CONFIG.
    `RedisAPI` | RedisAPI.`graphDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DEBUG.
    `RedisAPI` | RedisAPI.`graphDelete(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DELETE.
    `RedisAPI` | RedisAPI.`graphExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.EXPLAIN.
    `RedisAPI` | RedisAPI.`graphList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.LIST.
    `RedisAPI` | RedisAPI.`graphProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.PROFILE.
    `RedisAPI` | RedisAPI.`graphQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.QUERY.
    `RedisAPI` | RedisAPI.`graphRoQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.RO_QUERY.
    `RedisAPI` | RedisAPI.`graphSlowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.SLOWLOG.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)`
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Delete one or more hash fields.
    `RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Handshake with Redis.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a hash field exists.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the value of a hash field.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields and values in a hash.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the integer value of a hash field by the given number.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the float value of a hash field by the given amount.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields in a hash.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of fields in a hash.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given hash fields.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple hash fields to multiple values.
    `RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random fields from a hash.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate hash fields and associated values.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a hash field.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of a hash field, only if the field does not exist.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the length of the value of a hash field.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Get all the values in a hash.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by one.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by the given amount.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the float value of a key by the given amount.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Get information and statistics about the server.
    `RedisAPI` | RedisAPI.`jsonArrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRAPPEND.
    `RedisAPI` | RedisAPI.`jsonArrindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINDEX.
    `RedisAPI` | RedisAPI.`jsonArrinsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINSERT.
    `RedisAPI` | RedisAPI.`jsonArrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRLEN.
    `RedisAPI` | RedisAPI.`jsonArrpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRPOP.
    `RedisAPI` | RedisAPI.`jsonArrtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRTRIM.
    `RedisAPI` | RedisAPI.`jsonClear(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.CLEAR.
    `RedisAPI` | RedisAPI.`jsonDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEBUG.
    `RedisAPI` | RedisAPI.`jsonDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEL.
    `RedisAPI` | RedisAPI.`jsonForget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.FORGET.
    `RedisAPI` | RedisAPI.`jsonGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.GET.
    `RedisAPI` | RedisAPI.`jsonMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.MGET.
    `RedisAPI` | RedisAPI.`jsonNumincrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMINCRBY.
    `RedisAPI` | RedisAPI.`jsonNummultby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMMULTBY.
    `RedisAPI` | RedisAPI.`jsonNumpowby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMPOWBY.
    `RedisAPI` | RedisAPI.`jsonObjkeys(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJKEYS.
    `RedisAPI` | RedisAPI.`jsonObjlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJLEN.
    `RedisAPI` | RedisAPI.`jsonResp(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.RESP.
    `RedisAPI` | RedisAPI.`jsonSet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.SET.
    `RedisAPI` | RedisAPI.`jsonStrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRAPPEND.
    `RedisAPI` | RedisAPI.`jsonStrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRLEN.
    `RedisAPI` | RedisAPI.`jsonToggle(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TOGGLE.
    `RedisAPI` | RedisAPI.`jsonType(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TYPE.
    `RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Find all keys matching the given pattern.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Get the UNIX time stamp of the last successful save to disk.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` A container for latency diagnostics commands.
    `RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Find longest common substring.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get an element from a list by its index.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Insert an element before or after another element in a list.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of a list.
    `RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it.
    `RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Display some computer art and the Redis version.
    `RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first elements in a list.
    `RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Return the index of matching elements on a list.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend one or multiple elements to a list.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend an element to a list, only if the list exists.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a range of elements from a list.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove elements from a list.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of an element in a list by its index.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Trim a list to the specified range.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` A container for memory diagnostics commands.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given keys.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` A container for module commands.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Listen for all requests received by the server in real time.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Move a key to another database.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values, only if none of the keys exist.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Mark the start of a transaction block.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` A container for object introspection commands.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Remove the expiration from a key.
    `RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in milliseconds.
    `RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key in milliseconds.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Internal commands for debugging HyperLogLog values.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` An internal command for testing HyperLogLog values.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Ping the server.
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration in milliseconds of a key.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to channels matching the given patterns.
    `RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in milliseconds.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a channel.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Pub/Sub commands.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to channels matching the given patterns.
    `RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Close the connection.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Return a random key from the keyspace.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Enables read queries for a connection to a cluster replica node.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Disables read queries for a connection to a cluster replica node.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key, only if the new key does not exist.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for configuring the replication stream.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Reset the connection.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for migrating keys in a cluster.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Return the role of the instance in the context of replication.
    `RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last elements in a list.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Remove the last element in a list, prepend it to another list and return it.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Append one or multiple elements to a list.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Append an element to a list, only if the list exists.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a set.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate the keys space.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a set.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Lua scripts management commands.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Change the selected database for the current connection.
    `Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a key.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Sets or clears the bit at offset in the string value stored at key.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration of a key.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the value of a key, only if the key does not exist.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Overwrite part of a string at key starting at the specified offset.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk and then shut down the server.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets.
    `RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and return the cardinality of the result.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a given value is a member of a set.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` A container for slow log commands.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Get all the members in a set.
    `RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the membership associated with the given elements for a set.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Move a member from one set to another.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return one or multiple random members from a set.
    `RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a shard channel.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random members from a set.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a set.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate Set elements.
    `RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given shard channels.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of the value stored in a key.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given channels.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given shard channels.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Swaps two Redis databases.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | RedisAPI.`tdigestAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.ADD.
    `RedisAPI` | RedisAPI.`tdigestByrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYRANK.
    `RedisAPI` | RedisAPI.`tdigestByrevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYREVRANK.
    `RedisAPI` | RedisAPI.`tdigestCdf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CDF.
    `RedisAPI` | RedisAPI.`tdigestCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CREATE.
    `RedisAPI` | RedisAPI.`tdigestInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.INFO.
    `RedisAPI` | RedisAPI.`tdigestMax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MAX.
    `RedisAPI` | RedisAPI.`tdigestMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MERGE.
    `RedisAPI` | RedisAPI.`tdigestMin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MIN.
    `RedisAPI` | RedisAPI.`tdigestQuantile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.QUANTILE.
    `RedisAPI` | RedisAPI.`tdigestRank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RANK.
    `RedisAPI` | RedisAPI.`tdigestReset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RESET.
    `RedisAPI` | RedisAPI.`tdigestRevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.REVRANK.
    `RedisAPI` | RedisAPI.`tdigestTrimmedMean(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.TRIMMED_MEAN.
    `RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Return the current server time.
    `RedisAPI` | RedisAPI.`timeseriesClusterset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSET.
    `RedisAPI` | RedisAPI.`timeseriesClustersetfromshard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `RedisAPI` | RedisAPI.`timeseriesHello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.HELLO.
    `RedisAPI` | RedisAPI.`timeseriesInfocluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INFOCLUSTER.
    `RedisAPI` | RedisAPI.`timeseriesInnercommunication(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `RedisAPI` | RedisAPI.`timeseriesNetworktest(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.NETWORKTEST.
    `RedisAPI` | RedisAPI.`timeseriesRefreshcluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.REFRESHCLUSTER.
    `RedisAPI` | RedisAPI.`topkAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.ADD.
    `RedisAPI` | RedisAPI.`topkCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.COUNT.
    `RedisAPI` | RedisAPI.`topkIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INCRBY.
    `RedisAPI` | RedisAPI.`topkInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INFO.
    `RedisAPI` | RedisAPI.`topkList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.LIST.
    `RedisAPI` | RedisAPI.`topkQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.QUERY.
    `RedisAPI` | RedisAPI.`topkReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.RESERVE.
    `RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Alters the last access time of a key(s).
    `RedisAPI` | RedisAPI.`tsAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ADD.
    `RedisAPI` | RedisAPI.`tsAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ALTER.
    `RedisAPI` | RedisAPI.`tsCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATE.
    `RedisAPI` | RedisAPI.`tsCreaterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATERULE.
    `RedisAPI` | RedisAPI.`tsDecrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DECRBY.
    `RedisAPI` | RedisAPI.`tsDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DEL.
    `RedisAPI` | RedisAPI.`tsDeleterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DELETERULE.
    `RedisAPI` | RedisAPI.`tsGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.GET.
    `RedisAPI` | RedisAPI.`tsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INCRBY.
    `RedisAPI` | RedisAPI.`tsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INFO.
    `RedisAPI` | RedisAPI.`tsMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MADD.
    `RedisAPI` | RedisAPI.`tsMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MGET.
    `RedisAPI` | RedisAPI.`tsMrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MRANGE.
    `RedisAPI` | RedisAPI.`tsMrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MREVRANGE.
    `RedisAPI` | RedisAPI.`tsQueryindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.QUERYINDEX.
    `RedisAPI` | RedisAPI.`tsRange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.RANGE.
    `RedisAPI` | RedisAPI.`tsRevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.REVRANGE.
    `RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in seconds.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Determine the type stored at key.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key asynchronously in another thread.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given channels.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Forget about all watched keys.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Appends a new entry to a stream.
    `RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Removes the specified entries from the stream.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` A container for consumer groups commands.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` A container for stream introspection commands.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Return the number of entries in a stream.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for replicating stream values.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Trims the stream to (approximately if '~' is passed) a certain size.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a sorted set, or update its score if it already exists.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a sorted set.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the members in a sorted set with scores within the given values.
    `RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets.
    `RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the score of a member in a sorted set.
    `RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets.
    `RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and return the cardinality of the result.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the number of members in a sorted set between a given lexicographical range.
    `RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set.
    `RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Get the score associated with the given members in a sorted set.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the highest scores in a sorted set.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the lowest scores in a sorted set.
    `RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random elements from a sorted set.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score.
    `RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Store a range of members from sorted set into another key.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a sorted set.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set between the given lexicographical range.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given indexes.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given scores.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate sorted sets elements and associated scores.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the score associated with the given member in a sorted set.
    `RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key.

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery

    Methods in io.vertx.reactivex.servicediscovery with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(JsonObject filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(String id, Handler<AsyncResult<Record>> resultHandler)` Looks up for a single record by its registration `id`.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(JsonObject filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery bridge.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery service importer.
    `void` | ServiceDiscovery.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServiceDiscovery.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates the given record.

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery.spi

    Methods in io.vertx.reactivex.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceImporter.`close(Handler<Void> closeHandler)` Closes the importer
    `void` | ServiceExporter.`close(Handler<Void> closeHandler)` Close the exporter
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServicePublisher.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServicePublisher.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates an existing record.

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery.types

    Methods in io.vertx.reactivex.servicediscovery.types with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .

  - ### Uses of Handler in io.vertx.reactivex.sqlclient

    Methods in io.vertx.reactivex.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SqlConnection.`begin(Handler<AsyncResult<Transaction>> handler)` Begin a transaction and returns a `Transaction` for controlling and tracking this transaction.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | SqlConnection.`close(Handler<AsyncResult<Void>> handler)` Close the current connection after all the pending commands have been processed.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a `completionHandler` called when the cursor has been released.
    `void` | Pool.`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
    `void` | SqlClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release the associated resources.
    `void` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but notifies the `completionHandler` when it's closed.
    `SqlConnection` | SqlConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` with an handler to be notified when the transaction commit has completed
    `void` | Transaction.`completion(Handler<AsyncResult<Void>> handler)` Like `Transaction.completion(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a callback
    `Pool` | Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `RowStream<T>` | RowStream.`endHandler(Handler<Void> endHandler)`
    `RowStream<T>` | RowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SqlConnection` | SqlConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `void` | PreparedQuery.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | Query.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`execute(Tuple tuple, Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`executeBatch(List<Tuple> batch, Handler<AsyncResult<T>> handler)` Execute the query with a batch of tuples.
    `void` | Pool.`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
    `RowStream<T>` | RowStream.`handler(Handler<T> handler)`
    `void` | RowStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SqlConnection` | SqlConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.
    `SqlConnection` | SqlConnection.`prepare(String sql, PrepareOptions options, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.
    `void` | Cursor.`read(int count, Handler<AsyncResult<RowSet<Row>>> handler)` Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `void` | Transaction.`rollback(Handler<AsyncResult<Void>> handler)` Like `Transaction.rollback(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` with an handler to be notified when the transaction rollback has completed
    `ClientBuilder<C>` | ClientBuilder.`withConnectHandler(Handler<SqlConnection> handler)` Set a handler called when the pool has established a connection to the database.
    `<T> void` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Get a connection from the pool and execute the given `function`.
    `<T> void` | Pool.`withConnection(Function<SqlConnection,Maybe<T>> function, Handler<AsyncResult<T>> handler)` Get a connection from the pool and execute the given `function`.
    `<T> void` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withTransaction(Function<SqlConnection,Maybe<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> void` | Pool.`withTransaction(TransactionPropagation txPropagation, Function<SqlConnection,Maybe<T>> function, Handler<AsyncResult<T>> handler)` Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.

  - ### Uses of Handler in io.vertx.reactivex.sqlclient.templates

    Methods in io.vertx.reactivex.sqlclient.templates with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SqlTemplate.`execute(I parameters, Handler<AsyncResult<R>> handler)` Execute the query with the `parameters`
    `void` | SqlTemplate.`executeBatch(List<I> batch, Handler<AsyncResult<R>> handler)` Execute a batch query with the `batch`.

  - ### Uses of Handler in io.vertx.redis.client

    Methods in io.vertx.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Access List Control commands.
    `default RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Append a value to a key.
    `default RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Sent by cluster clients after an -ASK redirect.
    `default RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Authenticate to the server.
    `default Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `default RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `default RedisAPI` | RedisAPI.`bfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.ADD.
    `default RedisAPI` | RedisAPI.`bfCard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.CARD.
    `default RedisAPI` | RedisAPI.`bfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.DEBUG.
    `default RedisAPI` | RedisAPI.`bfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.EXISTS.
    `default RedisAPI` | RedisAPI.`bfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INFO.
    `default RedisAPI` | RedisAPI.`bfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INSERT.
    `default RedisAPI` | RedisAPI.`bfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.LOADCHUNK.
    `default RedisAPI` | RedisAPI.`bfMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MADD.
    `default RedisAPI` | RedisAPI.`bfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MEXISTS.
    `default RedisAPI` | RedisAPI.`bfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.RESERVE.
    `default RedisAPI` | RedisAPI.`bfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.SCANDUMP.
    `default RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Asynchronously rewrite the append-only file.
    `default RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Asynchronously save the dataset to disk.
    `default RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Count set bits in a string.
    `default RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `default RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `default RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Perform bitwise operations between strings.
    `default RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Find first bit set or clear in a string.
    `default RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `default RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list, or block until one is available.
    `default RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first element in a list, or block until one is available.
    `default RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last element in a list, or block until one is available.
    `default RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `default RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set or block until one is available.
    `default RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `default RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `default RedisAPI` | RedisAPI.`cfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADD.
    `default RedisAPI` | RedisAPI.`cfAddnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADDNX.
    `default RedisAPI` | RedisAPI.`cfCompact(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COMPACT.
    `default RedisAPI` | RedisAPI.`cfCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COUNT.
    `default RedisAPI` | RedisAPI.`cfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEBUG.
    `default RedisAPI` | RedisAPI.`cfDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEL.
    `default RedisAPI` | RedisAPI.`cfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.EXISTS.
    `default RedisAPI` | RedisAPI.`cfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INFO.
    `default RedisAPI` | RedisAPI.`cfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERT.
    `default RedisAPI` | RedisAPI.`cfInsertnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERTNX.
    `default RedisAPI` | RedisAPI.`cfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.LOADCHUNK.
    `default RedisAPI` | RedisAPI.`cfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.MEXISTS.
    `default RedisAPI` | RedisAPI.`cfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.RESERVE.
    `default RedisAPI` | RedisAPI.`cfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.SCANDUMP.
    `default RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` A container for client connection commands.
    `default RedisConnection` | RedisConnection.`close(Handler<AsyncResult<Void>> onClose)` Closes the connection or returns to the pool.
    `default RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` A container for cluster commands.
    `default RedisAPI` | RedisAPI.`cmsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INCRBY.
    `default RedisAPI` | RedisAPI.`cmsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INFO.
    `default RedisAPI` | RedisAPI.`cmsInitbydim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYDIM.
    `default RedisAPI` | RedisAPI.`cmsInitbyprob(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYPROB.
    `default RedisAPI` | RedisAPI.`cmsMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.MERGE.
    `default RedisAPI` | RedisAPI.`cmsQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.QUERY.
    `default RedisAPI` | RedisAPI.`command(List<String> args, Handler<AsyncResult<Response>> handler)` Get array of Redis command details.
    `default RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` A container for server configuration commands.
    `default Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `default RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Copy a key.
    `default RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Return the number of keys in the selected database.
    `default RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` A container for debugging commands.
    `default RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by one.
    `default RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by the given number.
    `default RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key.
    `default RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Discard all commands issued after MULTI.
    `default RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Return a serialized version of the value stored at the specified key.
    `default RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Echo the given string.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `default RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `default RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `default RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `default RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `default RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Execute all commands issued after MULTI.
    `default RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Determine if a key exists.
    `default RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in seconds.
    `default RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp.
    `default RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key.
    `default RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Start a coordinated failover between this server and one of its replicas.
    `default RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a function.
    `default RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a read-only function.
    `default RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from all databases.
    `default RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from the current database.
    `default RedisAPI` | RedisAPI.`ftAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ADD.
    `default RedisAPI` | RedisAPI.`ftAggregate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.AGGREGATE.
    `default RedisAPI` | RedisAPI.`ftAliasadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASADD.
    `default RedisAPI` | RedisAPI.`ftAliasaddifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASADDIFNX.
    `default RedisAPI` | RedisAPI.`ftAliasdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASDEL.
    `default RedisAPI` | RedisAPI.`ftAliasdelifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASDELIFX.
    `default RedisAPI` | RedisAPI.`ftAliasupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASUPDATE.
    `default RedisAPI` | RedisAPI.`ftAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALTER.
    `default RedisAPI` | RedisAPI.`ftAlterifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALTERIFNX.
    `default RedisAPI` | RedisAPI.`ftConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CONFIG.
    `default RedisAPI` | RedisAPI.`ftCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CREATE.
    `default RedisAPI` | RedisAPI.`ftCreateifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._CREATEIFNX.
    `default RedisAPI` | RedisAPI.`ftCursor(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CURSOR.
    `default RedisAPI` | RedisAPI.`ftDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEBUG.
    `default RedisAPI` | RedisAPI.`ftDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEL.
    `default RedisAPI` | RedisAPI.`ftDictadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTADD.
    `default RedisAPI` | RedisAPI.`ftDictdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDEL.
    `default RedisAPI` | RedisAPI.`ftDictdump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDUMP.
    `default RedisAPI` | RedisAPI.`ftDrop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROP.
    `default RedisAPI` | RedisAPI.`ftDropifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPIFX.
    `default RedisAPI` | RedisAPI.`ftDropindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROPINDEX.
    `default RedisAPI` | RedisAPI.`ftDropindexifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPINDEXIFX.
    `default RedisAPI` | RedisAPI.`ftExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAIN.
    `default RedisAPI` | RedisAPI.`ftExplaincli(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAINCLI.
    `default RedisAPI` | RedisAPI.`ftGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.GET.
    `default RedisAPI` | RedisAPI.`ftInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.INFO.
    `default RedisAPI` | RedisAPI.`ftList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._LIST.
    `default RedisAPI` | RedisAPI.`ftMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.MGET.
    `default RedisAPI` | RedisAPI.`ftProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.PROFILE.
    `default RedisAPI` | RedisAPI.`ftSafeadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SAFEADD.
    `default RedisAPI` | RedisAPI.`ftSearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SEARCH.
    `default RedisAPI` | RedisAPI.`ftSpellcheck(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SPELLCHECK.
    `default RedisAPI` | RedisAPI.`ftSugadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGADD.
    `default RedisAPI` | RedisAPI.`ftSugdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGDEL.
    `default RedisAPI` | RedisAPI.`ftSugget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGGET.
    `default RedisAPI` | RedisAPI.`ftSuglen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGLEN.
    `default RedisAPI` | RedisAPI.`ftSynadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNADD.
    `default RedisAPI` | RedisAPI.`ftSyndump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNDUMP.
    `default RedisAPI` | RedisAPI.`ftSynupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNUPDATE.
    `default RedisAPI` | RedisAPI.`ftTagvals(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.TAGVALS.
    `default RedisAPI` | RedisAPI.`function(List<String> args, Handler<AsyncResult<Response>> handler)` A container for function commands.
    `default RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `default RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the distance between two members of a geospatial index.
    `default RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Returns members of a geospatial index as standard geohash strings.
    `default RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Returns longitude and latitude of members of a geospatial index.
    `default RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `default RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `default RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUSBYMEMBER.
    `default RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUS.
    `default RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `default RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `default RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key.
    `default RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Returns the bit value at offset in the string value stored at key.
    `default RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key and delete the key.
    `default RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Get the value of a key and optionally set its expiration.
    `default RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `default RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the string value of a key and return its old value.
    `default RedisAPI` | RedisAPI.`graphBulk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.BULK.
    `default RedisAPI` | RedisAPI.`graphConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.CONFIG.
    `default RedisAPI` | RedisAPI.`graphDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DEBUG.
    `default RedisAPI` | RedisAPI.`graphDelete(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DELETE.
    `default RedisAPI` | RedisAPI.`graphExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.EXPLAIN.
    `default RedisAPI` | RedisAPI.`graphList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.LIST.
    `default RedisAPI` | RedisAPI.`graphProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.PROFILE.
    `default RedisAPI` | RedisAPI.`graphQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.QUERY.
    `default RedisAPI` | RedisAPI.`graphRoQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.RO_QUERY.
    `default RedisAPI` | RedisAPI.`graphSlowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.SLOWLOG.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)` Set a data handler.
    `default RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Delete one or more hash fields.
    `default RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Handshake with Redis.
    `default RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a hash field exists.
    `default RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the value of a hash field.
    `default RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields and values in a hash.
    `default RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the integer value of a hash field by the given number.
    `default RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the float value of a hash field by the given amount.
    `default RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields in a hash.
    `default RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of fields in a hash.
    `default RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given hash fields.
    `default RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple hash fields to multiple values.
    `default RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random fields from a hash.
    `default RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate hash fields and associated values.
    `default RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a hash field.
    `default RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of a hash field, only if the field does not exist.
    `default RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the length of the value of a hash field.
    `default RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Get all the values in a hash.
    `default RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by one.
    `default RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by the given amount.
    `default RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the float value of a key by the given amount.
    `default RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Get information and statistics about the server.
    `default RedisAPI` | RedisAPI.`jsonArrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRAPPEND.
    `default RedisAPI` | RedisAPI.`jsonArrindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINDEX.
    `default RedisAPI` | RedisAPI.`jsonArrinsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINSERT.
    `default RedisAPI` | RedisAPI.`jsonArrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRLEN.
    `default RedisAPI` | RedisAPI.`jsonArrpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRPOP.
    `default RedisAPI` | RedisAPI.`jsonArrtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRTRIM.
    `default RedisAPI` | RedisAPI.`jsonClear(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.CLEAR.
    `default RedisAPI` | RedisAPI.`jsonDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEBUG.
    `default RedisAPI` | RedisAPI.`jsonDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEL.
    `default RedisAPI` | RedisAPI.`jsonForget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.FORGET.
    `default RedisAPI` | RedisAPI.`jsonGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.GET.
    `default RedisAPI` | RedisAPI.`jsonMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.MGET.
    `default RedisAPI` | RedisAPI.`jsonNumincrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMINCRBY.
    `default RedisAPI` | RedisAPI.`jsonNummultby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMMULTBY.
    `default RedisAPI` | RedisAPI.`jsonNumpowby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMPOWBY.
    `default RedisAPI` | RedisAPI.`jsonObjkeys(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJKEYS.
    `default RedisAPI` | RedisAPI.`jsonObjlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJLEN.
    `default RedisAPI` | RedisAPI.`jsonResp(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.RESP.
    `default RedisAPI` | RedisAPI.`jsonSet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.SET.
    `default RedisAPI` | RedisAPI.`jsonStrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRAPPEND.
    `default RedisAPI` | RedisAPI.`jsonStrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRLEN.
    `default RedisAPI` | RedisAPI.`jsonToggle(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TOGGLE.
    `default RedisAPI` | RedisAPI.`jsonType(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TYPE.
    `default RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Find all keys matching the given pattern.
    `default RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Get the UNIX time stamp of the last successful save to disk.
    `default RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` A container for latency diagnostics commands.
    `default RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Find longest common substring.
    `default RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get an element from a list by its index.
    `default RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Insert an element before or after another element in a list.
    `default RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of a list.
    `default RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it.
    `default RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list.
    `default RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Display some computer art and the Redis version.
    `default RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first elements in a list.
    `default RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Return the index of matching elements on a list.
    `default RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend one or multiple elements to a list.
    `default RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend an element to a list, only if the list exists.
    `default RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a range of elements from a list.
    `default RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove elements from a list.
    `default RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of an element in a list by its index.
    `default RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Trim a list to the specified range.
    `default RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` A container for memory diagnostics commands.
    `default RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given keys.
    `default RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Atomically transfer a key from a Redis instance to another one.
    `default RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` A container for module commands.
    `default RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Listen for all requests received by the server in real time.
    `default RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Move a key to another database.
    `default RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values.
    `default RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values, only if none of the keys exist.
    `default RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Mark the start of a transaction block.
    `default RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` A container for object introspection commands.
    `default RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Remove the expiration from a key.
    `default RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in milliseconds.
    `default RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `default RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key in milliseconds.
    `default RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Adds the specified elements to the specified HyperLogLog.
    `default RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `default RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Internal commands for debugging HyperLogLog values.
    `default RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Merge N different HyperLogLogs into a single one.
    `default RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` An internal command for testing HyperLogLog values.
    `default RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Ping the server.
    `default RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration in milliseconds of a key.
    `default RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to channels matching the given patterns.
    `default RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `default RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in milliseconds.
    `default RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a channel.
    `default RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Pub/Sub commands.
    `default RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to channels matching the given patterns.
    `default RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Close the connection.
    `default RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Return a random key from the keyspace.
    `default RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Enables read queries for a connection to a cluster replica node.
    `default RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Disables read queries for a connection to a cluster replica node.
    `default RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key.
    `default RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key, only if the new key does not exist.
    `default RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for configuring the replication stream.
    `default RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `default RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Reset the connection.
    `default RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `default RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for migrating keys in a cluster.
    `default RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Return the role of the instance in the context of replication.
    `default RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last elements in a list.
    `default RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Remove the last element in a list, prepend it to another list and return it.
    `default RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Append one or multiple elements to a list.
    `default RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Append an element to a list, only if the list exists.
    `default RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a set.
    `default RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk.
    `default RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate the keys space.
    `default RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a set.
    `default RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Lua scripts management commands.
    `default RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets.
    `default RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets and store the resulting set in a key.
    `default RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Change the selected database for the current connection.
    `default Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `default RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `default RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a key.
    `default RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Sets or clears the bit at offset in the string value stored at key.
    `default RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration of a key.
    `default RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the value of a key, only if the key does not exist.
    `default RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Overwrite part of a string at key starting at the specified offset.
    `default RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk and then shut down the server.
    `default RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets.
    `default RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and return the cardinality of the result.
    `default RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and store the resulting set in a key.
    `default RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a given value is a member of a set.
    `default RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `default RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` A container for slow log commands.
    `default RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Get all the members in a set.
    `default RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the membership associated with the given elements for a set.
    `default RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Move a member from one set to another.
    `default RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `default RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `default RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return one or multiple random members from a set.
    `default RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a shard channel.
    `default RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random members from a set.
    `default RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a set.
    `default RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate Set elements.
    `default RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given shard channels.
    `default RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of the value stored in a key.
    `default RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given channels.
    `default RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `default RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets.
    `default RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets and store the resulting set in a key.
    `default RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given shard channels.
    `default RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Swaps two Redis databases.
    `default RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `default RedisAPI` | RedisAPI.`tdigestAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.ADD.
    `default RedisAPI` | RedisAPI.`tdigestByrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYRANK.
    `default RedisAPI` | RedisAPI.`tdigestByrevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYREVRANK.
    `default RedisAPI` | RedisAPI.`tdigestCdf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CDF.
    `default RedisAPI` | RedisAPI.`tdigestCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CREATE.
    `default RedisAPI` | RedisAPI.`tdigestInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.INFO.
    `default RedisAPI` | RedisAPI.`tdigestMax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MAX.
    `default RedisAPI` | RedisAPI.`tdigestMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MERGE.
    `default RedisAPI` | RedisAPI.`tdigestMin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MIN.
    `default RedisAPI` | RedisAPI.`tdigestQuantile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.QUANTILE.
    `default RedisAPI` | RedisAPI.`tdigestRank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RANK.
    `default RedisAPI` | RedisAPI.`tdigestReset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RESET.
    `default RedisAPI` | RedisAPI.`tdigestRevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.REVRANK.
    `default RedisAPI` | RedisAPI.`tdigestTrimmedMean(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.TRIMMED_MEAN.
    `default RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Return the current server time.
    `default RedisAPI` | RedisAPI.`timeseriesClusterset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSET.
    `default RedisAPI` | RedisAPI.`timeseriesClustersetfromshard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `default RedisAPI` | RedisAPI.`timeseriesHello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.HELLO.
    `default RedisAPI` | RedisAPI.`timeseriesInfocluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INFOCLUSTER.
    `default RedisAPI` | RedisAPI.`timeseriesInnercommunication(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `default RedisAPI` | RedisAPI.`timeseriesNetworktest(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.NETWORKTEST.
    `default RedisAPI` | RedisAPI.`timeseriesRefreshcluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.REFRESHCLUSTER.
    `default RedisAPI` | RedisAPI.`topkAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.ADD.
    `default RedisAPI` | RedisAPI.`topkCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.COUNT.
    `default RedisAPI` | RedisAPI.`topkIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INCRBY.
    `default RedisAPI` | RedisAPI.`topkInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INFO.
    `default RedisAPI` | RedisAPI.`topkList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.LIST.
    `default RedisAPI` | RedisAPI.`topkQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.QUERY.
    `default RedisAPI` | RedisAPI.`topkReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.RESERVE.
    `default RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Alters the last access time of a key(s).
    `default RedisAPI` | RedisAPI.`tsAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ADD.
    `default RedisAPI` | RedisAPI.`tsAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ALTER.
    `default RedisAPI` | RedisAPI.`tsCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATE.
    `default RedisAPI` | RedisAPI.`tsCreaterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATERULE.
    `default RedisAPI` | RedisAPI.`tsDecrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DECRBY.
    `default RedisAPI` | RedisAPI.`tsDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DEL.
    `default RedisAPI` | RedisAPI.`tsDeleterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DELETERULE.
    `default RedisAPI` | RedisAPI.`tsGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.GET.
    `default RedisAPI` | RedisAPI.`tsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INCRBY.
    `default RedisAPI` | RedisAPI.`tsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INFO.
    `default RedisAPI` | RedisAPI.`tsMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MADD.
    `default RedisAPI` | RedisAPI.`tsMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MGET.
    `default RedisAPI` | RedisAPI.`tsMrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MRANGE.
    `default RedisAPI` | RedisAPI.`tsMrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MREVRANGE.
    `default RedisAPI` | RedisAPI.`tsQueryindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.QUERYINDEX.
    `default RedisAPI` | RedisAPI.`tsRange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.RANGE.
    `default RedisAPI` | RedisAPI.`tsRevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.REVRANGE.
    `default RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in seconds.
    `default RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Determine the type stored at key.
    `default RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key asynchronously in another thread.
    `default RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given channels.
    `default RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Forget about all watched keys.
    `default RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `default RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `default RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `default RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Appends a new entry to a stream.
    `default RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `default RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `default RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Removes the specified entries from the stream.
    `default RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` A container for consumer groups commands.
    `default RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` A container for stream introspection commands.
    `default RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Return the number of entries in a stream.
    `default RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `default RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `default RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `default RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `default RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `default RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for replicating stream values.
    `default RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Trims the stream to (approximately if '~' is passed) a certain size.
    `default RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a sorted set, or update its score if it already exists.
    `default RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a sorted set.
    `default RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the members in a sorted set with scores within the given values.
    `default RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets.
    `default RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `default RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the score of a member in a sorted set.
    `default RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets.
    `default RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and return the cardinality of the result.
    `default RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `default RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the number of members in a sorted set between a given lexicographical range.
    `default RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set.
    `default RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Get the score associated with the given members in a sorted set.
    `default RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the highest scores in a sorted set.
    `default RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the lowest scores in a sorted set.
    `default RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random elements from a sorted set.
    `default RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set.
    `default RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range.
    `default RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score.
    `default RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Store a range of members from sorted set into another key.
    `default RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set.
    `default RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a sorted set.
    `default RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set between the given lexicographical range.
    `default RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given indexes.
    `default RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given scores.
    `default RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `default RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `default RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `default RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `default RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate sorted sets elements and associated scores.
    `default RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the score associated with the given member in a sorted set.
    `default RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets.
    `default RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key.

  - ### Uses of Handler in io.vertx.rx.java

    Classes in io.vertx.rx.java that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HandlerAdapter<T>`

    Fields in io.vertx.rx.java with type parameters of type Handler
    Modifier and Type | Field and Description
    --- | ---
    `protected java.util.function.Consumer<Handler<AsyncResult<T>>>` | SingleOnSubscribeAdapter.`consumer`

    Methods in io.vertx.rx.java that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(Action1<T> onNext)` Adapt an item callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(Action1<T> onNext, Action1<Throwable> onError)` Adapt an item callback and an error callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(Action1<T> onNext, Action1<Throwable> onError, Action0 onComplete)` Adapt an item callback and an error callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(Observer<T> observer)` Adapt a `Subscriber` as a `Handler<AsyncResult<T>>;`.
    `Handler<T>` | ObservableHandler.`toHandler()`
    `Handler<AsyncResult<T>>` | ObservableFuture.`toHandler()`
    `static <T> Handler<T>` | RxHelper.`toHandler(Action1<T> onNext)` Adapt an item callback as a `Handler<T>`.
    `static <T> Handler<T>` | RxHelper.`toHandler(Observer<T> observer)` Adapt a `Subscriber` as a `Handler<T>;`. When the event handler completes, the observer will complete immediatly after the event is received, as a single event is expected.
    `static <T> Handler<T>` | RxHelper.`toHandler(Observer<T> observer, boolean multi)` Adapt a `Subscriber` as a `Handler<T>;`. When parameter is false and the event handler completes, the observer will complete immediatly after the event is received, as a single event is expected.

    Methods in io.vertx.rx.java with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<J>` | ReadStreamSubscriber.`endHandler(Handler<Void> handler)`
    `ReadStream<J>` | ReadStreamSubscriber.`exceptionHandler(Handler<Throwable> handler)`
    `ReadStream<J>` | ReadStreamSubscriber.`handler(Handler<J> handler)`
    `static <T> Subscriber<T>` | RxHelper.`toSubscriber(Handler<AsyncResult<T>> handler)` Adapts a Vert.x `Handler<AsyncResult<T>>` to an RxJava `Subscriber`.

    Constructor parameters in io.vertx.rx.java with type arguments of type Handler
    Constructor and Description
    `SingleOnSubscribeAdapter(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)`

  - ### Uses of Handler in io.vertx.rxjava.amqp

    Methods in io.vertx.rxjava.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | AmqpSender.`end(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AmqpSender.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.
    `void` | AmqpSender.`write(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.cassandra

    Methods in io.vertx.rxjava.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.cassandra.ResultSet>>)` or .
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `CassandraClient` | CassandraClient.`execute(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `void` | ResultSet.`fetchNextPage(Handler<AsyncResult<ResultSet>> handler)` Like `ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.cassandra.ResultSet>>)` but with a direct callback.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)`
    `void` | CassandraClient.`metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)` Get for the session.
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst, Handler<AsyncResult<Void>> handler)`
    `CassandraClient` | CassandraClient.`prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided a .
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.oss.driver.api.core.cql.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

  - ### Uses of Handler in io.vertx.rxjava.circuitbreaker

    Methods in io.vertx.rxjava.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to close.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to open.
    `<T> Single<T>` | CircuitBreaker.`rxExecute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.

  - ### Uses of Handler in io.vertx.rxjava.config

    Methods in io.vertx.rxjava.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> handler)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.rxjava.core

    Methods in io.vertx.rxjava.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxBuilder.`buildClustered(Handler<AsyncResult<Vertx>> handler)` Creates a clustered instance.
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)` Deprecated.
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
    `<T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Context.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | Vertx.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)` Deprecated.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Deprecated.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setPeriodic(long initialDelay, long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.rxjava.core.datagram

    Methods in io.vertx.rxjava.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address and notifies the once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<Void>> handler)` Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)` Deprecated.
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<Void>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.rxjava.core.dns

    Methods in io.vertx.rxjava.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | DnsClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.rxjava.core.eventbus

    Methods in io.vertx.rxjava.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(MessageConsumerOptions options, Handler<Message<T>> handler)` Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(io.vertx.core.eventbus.MessageConsumerOptions)` but the address won't be propagated across the cluster.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>)`
    `<R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like `Message.replyAndRequest(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.eventbus.Message<R>>>)` but specifying `options` that can be used to configure the delivery.
    `<R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.request(java.lang.String, java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.eventbus.Message<T>>>)` but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `void` | MessageProducer.`write(T body, Handler<AsyncResult<Void>> handler)` Write a message to the event-bus, either sending or publishing.

  - ### Uses of Handler in io.vertx.rxjava.core.file

    Methods in io.vertx.rxjava.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deprecated.
    `FileSystem` | FileSystem.`deleteRecursive(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `void` | AsyncFile.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `void` | AsyncFileLock.`isValid(Handler<AsyncResult<Boolean>> handler)` Like `AsyncFileLock.isValid(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but the `handler` will be called when the operation completes or if an error occurs.
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `void` | AsyncFile.`lock(Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `void` | AsyncFile.`lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)` Like `AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `void` | AsyncFileLock.`release(Handler<AsyncResult<Void>> handler)` Like `AsyncFileLock.release(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the `handler` will be called when the operation completes or if an error occurs.
    `void` | AsyncFile.`size(Handler<AsyncResult<Long>> handler)` Like `AsyncFile.size(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)` but the `handler` will be called when the operation is complete or if an error occurs.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `void` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.rxjava.core.http

    Methods in io.vertx.rxjava.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpClientResponse` | HttpClientResponse.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | WebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | ServerWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | HttpClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`closeHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `void` | ClientWebSocket.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | WebSocketClient.`connect(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `void` | ClientWebSocket.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and port.
    `void` | WebSocketClient.`connect(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `void` | ClientWebSocket.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket to the host and relative request URI and default port.
    `void` | WebSocketClient.`connect(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the default client port and specified host and relative request URI.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a Continue handler has been set using this method, then the `handler` will be called.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler(Handler<MultiMap> handler)` If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `void` | WebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpServerRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerRequest.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | ServerWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `ClientWebSocket` | ClientWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ClientWebSocket` | ClientWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ClientWebSocket` | ClientWebSocket.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler(Handler<HttpServerRequest> handler)` Set a `handler` for handling invalid requests.
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ClientWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`pongHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with no headers.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, HostAndPort authority, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `void` | HttpClient.`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` | HttpClient.`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` | HttpClient.`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` | HttpClient.`request(RequestOptions options, Handler<AsyncResult<HttpClientRequest>> handler)` Create an HTTP request to send to the server.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpClientRequest` | HttpClientRequest.`response(Handler<AsyncResult<HttpClientResponse>> handler)` Set a callback for the associated `HttpClientResponse`.
    `void` | HttpClientRequest.`send(Buffer body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a buffer `body`.
    `void` | HttpServerResponse.`send(Buffer body, Handler<AsyncResult<Void>> handler)` Send the request with a buffer `body`.
    `void` | HttpClientRequest.`send(Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with an empty body.
    `void` | HttpServerResponse.`send(Handler<AsyncResult<Void>> handler)` Send the request with an empty body.
    `void` | HttpClientRequest.`send(Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a stream `body`.
    `void` | HttpServerResponse.`send(Observable<Buffer> body, Handler<AsyncResult<Void>> handler)` Send the request with a stream `body`.
    `void` | HttpClientRequest.`send(ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a stream `body`.
    `void` | HttpServerResponse.`send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler)` Send the request with a stream `body`.
    `void` | HttpClientRequest.`send(String body, Handler<AsyncResult<HttpClientResponse>> handler)` Send the request with a string `body`.
    `void` | HttpServerResponse.`send(String body, Handler<AsyncResult<Void>> handler)` Send the request with a string `body`.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<AsyncResult<Void>> completionHandler)` Like `HttpClientRequest.sendHead(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Deprecated.
    `void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Shutdown a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Deprecated.
    `void` | HttpConnection.`shutdown(long timeout, TimeUnit unit, Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `WebSocketBase` | WebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler(Handler<String> handler)`
    `WebSocketBase` | ServerWebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `void` | HttpServerRequest.`toNetSocket(Handler<AsyncResult<NetSocket>> handler)` Establish a TCP tunnel with the client.
    `void` | HttpServerRequest.`toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)` Upgrade the connection of the current request to a WebSocket.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `void` | WebSocketClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | WebSocketClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebSocketClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | HttpClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `HttpClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Deprecated.
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler(Handler<ServerWebSocketHandshake> handler)` Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `void` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ClientWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`writeEarlyHints(MultiMap headers, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.writeEarlyHints(io.vertx.rxjava.core.MultiMap, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(io.vertx.rxjava.core.http.WebSocketFrame, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.core.net

    Methods in io.vertx.rxjava.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be notified when close is complete.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>)` but providing a handler that will be notified when the server is listening, or fails.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `void` | NetClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetServer.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | NetServer.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `NetServer.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<AsyncResult<Void>> handler)` Upgrade channel to use SSL/TLS.
    `void` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the message has been written or failed to be written.
    `void` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.core.parsetools

    Methods in io.vertx.rxjava.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.rxjava.core.shareddata

    Methods in io.vertx.rxjava.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`keys(Handler<AsyncResult<Set<K>>> resultHandler)` Get the keys of the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replace(K k, V v, long ttl, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, long ttl, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map
    `void` | AsyncMap.`values(Handler<AsyncResult<List<V>>> resultHandler)` Get the values of the map, asynchronously.

  - ### Uses of Handler in io.vertx.rxjava.core.streams

    Methods in io.vertx.rxjava.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `void` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.db2client

    Methods in io.vertx.rxjava.db2client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static SqlClient` | DB2Builder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler(Handler<Void> handler)`
    `static void` | DB2Connection.`connect(Vertx vertx, DB2ConnectOptions connectOptions, Handler<AsyncResult<DB2Connection>> handler)` Create a connection to DB2 server with the given `connectOptions`.
    `static void` | DB2Connection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<DB2Connection>> handler)` Like `DB2Connection.connect(io.vertx.rxjava.core.Vertx, io.vertx.db2client.DB2ConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.db2client.DB2Connection>>)` with options build from `connectionUri`.
    `DB2Pool` | DB2Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`exceptionHandler(Handler<Throwable> handler)`
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | DB2Builder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.auth

    Methods in io.vertx.rxjava.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `User` | User.`isAuthorized(Authorization authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.authentication

    Methods in io.vertx.rxjava.ext.auth.authentication with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthenticationProvider.`authenticate(Credentials credentials, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `void` | AuthenticationProvider.`authenticate(JsonObject credentials, Handler<AsyncResult<User>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.authorization

    Methods in io.vertx.rxjava.ext.auth.authorization with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthorizationProvider.`getAuthorizations(User user, Handler<AsyncResult<Void>> handler)` Updates the user with the set of authorizations.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.jdbc

    Methods in io.vertx.rxjava.ext.auth.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JDBCUserUtil` | JDBCUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `JDBCUserUtil` | JDBCUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.mongo

    Methods in io.vertx.rxjava.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoUserUtil` | MongoUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `MongoUserUtil` | MongoUserUtil.`createUser(String username, String password, Handler<AsyncResult<String>> resultHandler)` Insert a user into a database.
    `MongoUserUtil` | MongoUserUtil.`createUserRolesAndPermissions(String username, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a user role into a database.
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.oauth2

    Methods in io.vertx.rxjava.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`jWKSet(Handler<AsyncResult<Void>> handler)` Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler(Handler<String> handler)` Handled to be called when a key (mentioned on a JWT) is missing from the current config.
    `OAuth2Auth` | OAuth2Auth.`refresh(User user, Handler<AsyncResult<User>> handler)` Refresh the current User (access token).
    `OAuth2Auth` | OAuth2Auth.`revoke(User user, Handler<AsyncResult<Void>> handler)` Revoke an obtained access token.
    `OAuth2Auth` | OAuth2Auth.`revoke(User user, String tokenType, Handler<AsyncResult<Void>> handler)` Revoke an obtained access or refresh token.
    `OAuth2Auth` | OAuth2Auth.`userInfo(User user, Handler<AsyncResult<JsonObject>> handler)` Retrieve profile information and other attributes for a logged-in end-user.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.oauth2.providers

    Methods in io.vertx.rxjava.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AmazonCognitoAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | IBMCloudAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2Options config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.sqlclient

    Methods in io.vertx.rxjava.ext.auth.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SqlUserUtil` | SqlUserUtil.`createHashedUser(String username, String hash, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `SqlUserUtil` | SqlUserUtil.`createRolePermission(String role, String permission, Handler<AsyncResult<Void>> resultHandler)` Insert a role permission into a database.
    `SqlUserUtil` | SqlUserUtil.`createUser(String username, String password, Handler<AsyncResult<Void>> resultHandler)` Insert a user into a database.
    `SqlUserUtil` | SqlUserUtil.`createUserRole(String username, String role, Handler<AsyncResult<Void>> resultHandler)` Insert a user role into a database.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.webauthn

    Methods in io.vertx.rxjava.ext.auth.webauthn with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebAuthn` | WebAuthn.`createCredentialsOptions(JsonObject user, Handler<AsyncResult<JsonObject>> handler)` Gets a challenge and any other parameters for the `navigator.credentials.create()` call.
    `MetaDataService` | MetaDataService.`fetchTOC(Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
    `MetaDataService` | MetaDataService.`fetchTOC(String url, Handler<AsyncResult<Boolean>> handler)` Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
    `WebAuthn` | WebAuthn.`getCredentialsOptions(String name, Handler<AsyncResult<JsonObject>> handler)` Creates an assertion challenge and any other parameters for the `navigator.credentials.get()` call.

  - ### Uses of Handler in io.vertx.rxjava.ext.consul

    Methods in io.vertx.rxjava.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String accessorId, CloneAclTokenOptions cloneAclToken, Handler<AsyncResult<AclToken>> resultHandler)` Clones an existing ACL token
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `ConsulClient` | ConsulClient.`createAclPolicy(AclPolicy policy, Handler<AsyncResult<String>> resultHandler)` Creates a new ACL policy
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Create an Acl token
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`deleteAclToken(String accessorId, Handler<AsyncResult<Boolean>> resultHandler)` Deletes an ACL token
    `ConsulClient` | ConsulClient.`deletePolicy(String id, Handler<AsyncResult<Boolean>> resultHandler)` This endpoint deletes an ACL policy
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulClient` | ConsulClient.`deregisterCatalogService(String nodeId, String serviceId, Handler<AsyncResult<Void>> resultHandler)` Deregister entities from the node or deregister the node itself.
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`getAclPolicies(Handler<AsyncResult<List<AclPolicy>>> resultHandler)` This endpoint lists all the ACL policies.
    `ConsulClient` | ConsulClient.`getAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthNodesWithOptions(String node, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks specific to the node provided on the path.
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`readAclToken(String accessorId, Handler<AsyncResult<AclToken>> resultHandler)` Reads an ACL token with the given Accessor ID
    `ConsulClient` | ConsulClient.`readPolicy(String id, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given ID
    `ConsulClient` | ConsulClient.`readPolicyByName(String name, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint reads an ACL policy with the given name
    `ConsulClient` | ConsulClient.`registerCatalogService(Node nodeOptions, ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Register node with external service
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Deprecated.
    `ConsulClient` | ConsulClient.`updateAclToken(String accessorId, AclToken token, Handler<AsyncResult<AclToken>> resultHandler)` Update an existing Acl token
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updatePolicy(String id, AclPolicy policy, Handler<AsyncResult<AclPolicy>> resultHandler)` This endpoint updates an existing ACL policy
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".

  - ### Uses of Handler in io.vertx.rxjava.ext.eventbus.bridge.tcp

    Methods in io.vertx.rxjava.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.rxjava.ext.healthchecks

    Methods in io.vertx.rxjava.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HealthChecks.`checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedures.
    `void` | HealthChecks.`checkStatus(String name, Handler<AsyncResult<CheckResult>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.rxjava.ext.jdbc

    Methods in io.vertx.rxjava.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.rxjava.ext.mail

    Methods in io.vertx.rxjava.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MailClient.`close(Handler<AsyncResult<Void>> closedHandler)` Close the MailClient
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.rxjava.ext.mongo

    Methods in io.vertx.rxjava.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `void` | MongoClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release its resources
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`countWithOptions(String collection, JsonObject query, CountOptions countOptions, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | MongoClient.`createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions, Handler<AsyncResult<Void>> resultHandler)` Create a new collection with options
    `MongoClient` | MongoClient.`createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createGridFsBucketService(String bucketName, Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoClient` | MongoClient.`createIndexes(String collection, List<IndexModel> indexes, Handler<AsyncResult<Void>> resultHandler)` creates an indexes
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoGridFsClient` | MongoGridFsClient.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes a file by it's ID
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadFile(String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileAs(String fileName, String newFileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file and gives it a new name.
    `MongoGridFsClient` | MongoGridFsClient.`downloadFileByID(String id, String fileName, Handler<AsyncResult<Long>> resultHandler)` Downloads a file using the ID generated by GridFs.
    `MongoGridFsClient` | MongoGridFsClient.`drop(Handler<AsyncResult<Void>> resultHandler)` Drops the entire file bucket with all of its contents
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoGridFsClient` | MongoGridFsClient.`findAllIds(Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids in the bucket
    `MongoGridFsClient` | MongoGridFsClient.`findIds(JsonObject query, Handler<AsyncResult<List<String>>> resultHandler)` Finds all file ids that match a query.
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonArray update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Observable<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Observable<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadFile(String fileName, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs
    `MongoGridFsClient` | MongoGridFsClient.`uploadFileWithOptions(String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)` Upload a file to gridfs with options

  - ### Uses of Handler in io.vertx.rxjava.ext.shell

    Methods in io.vertx.rxjava.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.command

    Methods in io.vertx.rxjava.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.system

    Methods in io.vertx.rxjava.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.term

    Methods in io.vertx.rxjava.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Bind the term server, the `TermServer.termHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.shell.term.Term>)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.rxjava.ext.sql

    Methods in io.vertx.rxjava.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.rxjava.ext.stomp

    Methods in io.vertx.rxjava.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the able to manage web socket connections.

    Methods in io.vertx.rxjava.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<AsyncResult<Frame>> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompClientConnection` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<AsyncResult<Frame>> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.rxjava.ext.unit

    Methods in io.vertx.rxjava.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.rxjava.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | Async.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | TestCompletion.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.collect

    Methods in io.vertx.rxjava.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.report

    Methods in io.vertx.rxjava.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Handler in io.vertx.rxjava.ext.web

    Methods in io.vertx.rxjava.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `RoutingContext` | RoutingContext.`end(Buffer buffer, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `RoutingContext` | RoutingContext.`end(Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `RoutingContext` | RoutingContext.`end(String chunk, Handler<AsyncResult<Void>> handler)` See `RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `void` | UserContext.`impersonate(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`impersonate(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `RoutingContext` | RoutingContext.`json(Object json, Handler<AsyncResult<Void>> handler)` See `RoutingContext.json(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `void` | UserContext.`logout(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`logout(String redirectUri, Handler<AsyncResult<Void>> callback)`
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.
    `RoutingContext` | RoutingContext.`redirect(String url, Handler<AsyncResult<Void>> handler)` See `RoutingContext.redirect(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`.
    `void` | UserContext.`restore(Handler<AsyncResult<Void>> callback)`
    `void` | UserContext.`restore(String redirectUri, Handler<AsyncResult<Void>> callback)`

  - ### Uses of Handler in io.vertx.rxjava.ext.web.api.contract

    Methods in io.vertx.rxjava.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.api.contract.openapi3

    Methods in io.vertx.rxjava.ext.web.api.contract.openapi3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | OpenAPI3RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Deprecated.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.client

    Methods in io.vertx.rxjava.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendForm(MultiMap body, String charset, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(Observable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | WebClient.`updateSSLOptions(SSLOptions options, boolean force, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).
    `void` | WebClient.`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Boolean>> handler)` Like `WebClient.updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)` but supplying a handler that will be called when the update happened (or has failed).

  - ### Uses of Handler in io.vertx.rxjava.ext.web.common.template

    Methods in io.vertx.rxjava.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler

    Methods in io.vertx.rxjava.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `SessionHandler` | SessionHandler.`flush(RoutingContext ctx, boolean ignoreStatus, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `SessionHandler` | SessionHandler.`flush(RoutingContext ctx, Handler<AsyncResult<Void>> handler)` Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `SessionHandler` | SessionHandler.`setUser(RoutingContext context, User user, Handler<AsyncResult<Void>> handler)` Set the user for the session

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler.graphql

    Methods in io.vertx.rxjava.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)` Deprecated.
    `GraphQLHandler` | GraphQLHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)` Deprecated.
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated.
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler.graphql.ws

    Methods in io.vertx.rxjava.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandler` | GraphQLWSHandler.`beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Deprecated.
    `GraphQLWSHandler` | GraphQLWSHandler.`messageHandler(Handler<Message> messageHandler)` Deprecated.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit(Handler<ConnectionInitEvent> connectionInitHandler)` Customize the connection init .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage(Handler<Message> messageHandler)` Customize the message .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd(Handler<ServerWebSocket> endHandler)` Customize the end .

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler.sockjs

    Methods in io.vertx.rxjava.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `Router` | SockJSHandler.`bridge(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler(Handler<Void> closeHandler)`
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `void` | SockJSSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | SockJSSocket.`end(Handler<AsyncResult<Void>> handler)` Same as `SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.web.sstore

    Methods in io.vertx.rxjava.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SessionStore` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `SessionStore` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `SessionStore` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `SessionStore` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `SessionStore` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.rxjava.grpc.client

    Methods in io.vertx.rxjava.grpc.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Deprecated.
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`drainHandler(Handler<Void> handler)`
    `void` | GrpcClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcClientRequest.`end(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`endHandler(Handler<Void> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`errorHandler(Handler<GrpcError> handler)`
    `GrpcClientRequest<Req,Resp>` | GrpcClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`handler(Handler<Resp> handler)`
    `GrpcReadStream<Resp>` | GrpcClientResponse.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcClientResponse<Req,Resp>` | GrpcClientResponse.`messageHandler(Handler<GrpcMessage> handler)`
    `void` | GrpcClientResponse.`pipeTo(WriteStream<Resp> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<Req,Resp,T> Single<T>` | GrpcClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Deprecated.
    `void` | GrpcClientRequest.`write(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.grpc.common

    Methods in io.vertx.rxjava.grpc.common with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler(Handler<Void> handler)`
    `void` | GrpcWriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcWriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler(Handler<GrpcError> handler)` Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`handler(Handler<T> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler(Handler<GrpcMessage> handler)` Set a handler to be notified with incoming encoded messages.
    `void` | GrpcReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcWriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.grpc.server

    Methods in io.vertx.rxjava.grpc.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcServer` | GrpcServer.`callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler)` Set a call handler that handles any call made to the server.
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Deprecated.
    `<Req,Resp> GrpcServer` | GrpcServer.`callHandler(ServiceMethod<Req,Resp> serviceMethod, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`drainHandler(Handler<Void> handler)`
    `void` | GrpcServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | GrpcServerResponse.`end(Resp data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`endHandler(Handler<Void> endHandler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`errorHandler(Handler<GrpcError> handler)`
    `GrpcServerResponse<Req,Resp>` | GrpcServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`handler(Handler<Req> handler)`
    `GrpcReadStream<Req>` | GrpcServerRequest.`invalidMessageHandler(Handler<InvalidMessageException> handler)` Set a message handler that is reported with invalid message errors.
    `GrpcServerRequest<Req,Resp>` | GrpcServerRequest.`messageHandler(Handler<GrpcMessage> handler)`
    `void` | GrpcServerRequest.`pipeTo(WriteStream<Req> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcServerResponse.`write(Resp data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.grpcio.client

    Methods in io.vertx.rxjava.grpcio.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcIoClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `<Req,Resp,T> Single<T>` | GrpcIoClient.`rxCall(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.

  - ### Uses of Handler in io.vertx.rxjava.grpcio.server

    Methods in io.vertx.rxjava.grpcio.server with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp> GrpcIoServer` | GrpcIoServer.`callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc, Handler<GrpcServerRequest<Req,Resp>> handler)` Set a service method call handler that handles any call made to the server for the service method.

  - ### Uses of Handler in io.vertx.rxjava.json.schema

    Methods in io.vertx.rxjava.json.schema with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SchemaRouter.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser, Handler<AsyncResult<Schema>> handler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.kafka.admin

    Methods in io.vertx.rxjava.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> handler)` Close the admin client
    `void` | KafkaAdminClient.`createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Create the ACL rules.
    `void` | KafkaAdminClient.`createPartitions(Map<String,NewPartitions> partitions, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new partitions in the Kafka topic
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Delete the ACL rules.
    `void` | KafkaAdminClient.`deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions, Handler<AsyncResult<Void>> completionHandler)` Delete committed offsets for a set of partitions in a consumer group.
    `void` | KafkaAdminClient.`deleteConsumerGroups(List<String> groupIds, Handler<AsyncResult<Void>> completionHandler)` Delete consumer groups from the cluster.
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter, Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)` Describe the ACL rules.
    `void` | KafkaAdminClient.`describeCluster(DescribeClusterOptions options, Handler<AsyncResult<ClusterDescription>> completionHandler)` Like `KafkaAdminClient.describeCluster(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.kafka.admin.ClusterDescription>>)` but allows customized options.
    `void` | KafkaAdminClient.`describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)` Describe the nodes in the cluster with the default options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Like `KafkaAdminClient.describeConsumerGroups(java.util.List<java.lang.String>, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.Map<java.lang.String, io.vertx.kafka.admin.ConsumerGroupDescription>>>)` but allows customized options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Describe some group ids in the cluster, with the default options
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, DescribeTopicsOptions options, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Like `KafkaAdminClient.describeTopics(java.util.List<java.lang.String>, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.Map<java.lang.String, io.vertx.kafka.admin.TopicDescription>>>)` but allows for customised otions
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Describe some topics in the cluster, with the default options.
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.rxjava.kafka.client.consumer

    Methods in io.vertx.rxjava.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | KafkaConsumer.`poll(java.time.Duration timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka.
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.rxjava.kafka.client.producer

    Methods in io.vertx.rxjava.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaProducer<K,V>` | KafkaProducer.`abortTransaction(Handler<AsyncResult<Void>> handler)` Aborts the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`beginTransaction(Handler<AsyncResult<Void>> handler)` Starts a new kafka transaction.
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `KafkaProducer<K,V>` | KafkaProducer.`commitTransaction(Handler<AsyncResult<Void>> handler)` Commits the ongoing transaction.
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `void` | KafkaProducer.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | KafkaProducer.`end(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<AsyncResult<Void>> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`initTransactions(Handler<AsyncResult<Void>> handler)` Initializes the underlying kafka transactional producer.
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `void` | KafkaProducer.`write(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.micrometer

    Methods in io.vertx.rxjava.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(io.micrometer.prometheus.PrometheusMeterRegistry registry)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.rxjava.mqtt

    Methods in io.vertx.rxjava.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)` Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)` Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(List<String> topics, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topics
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.rxjava.mssqlclient

    Methods in io.vertx.rxjava.mssqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MSSQLConnection.`connect(Vertx vertx, MSSQLConnectOptions connectOptions, Handler<AsyncResult<MSSQLConnection>> handler)` Create a connection to SQL Server with the given `connectOptions`.
    `static void` | MSSQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MSSQLConnection>> handler)` Like `MSSQLConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.mssqlclient.MSSQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.mssqlclient.MSSQLConnection>>)` with options built from `connectionUri`.
    `MSSQLPool` | MSSQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MSSQLConnection` | MSSQLConnection.`infoHandler(Handler<MSSQLInfo> handler)` Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.mysqlclient

    Methods in io.vertx.rxjava.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static SqlClient` | MySQLBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.mysqlclient.MySQLConnection>>)` with options built from `connectionUri`.
    `MySQLPool` | MySQLPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `static Pool` | MySQLBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.rxjava.oracleclient

    Methods in io.vertx.rxjava.oracleclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OracleConnection` | OracleConnection.`closeHandler(Handler<Void> handler)`
    `static void` | OracleConnection.`connect(Vertx vertx, io.vertx.oracleclient.OracleConnectOptions connectOptions, Handler<AsyncResult<OracleConnection>> handler)` Create a connection to Oracle with the given `connectOptions`.
    `OraclePool` | OraclePool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `OracleConnection` | OracleConnection.`exceptionHandler(Handler<Throwable> handler)`
    `static Pool` | OracleBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `OracleConnection` | OracleConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.pgclient

    Methods in io.vertx.rxjava.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static SqlClient` | PgBuilder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)`
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>)` with options build from `connectionUri`.
    `PgPool` | PgPool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)`
    `PgConnection` | PgConnection.`noticeHandler(Handler<PgNotice> handler)` Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.pgclient.pubsub

    Methods in io.vertx.rxjava.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | PgSubscriber.`close(Handler<AsyncResult<Void>> handler)` Close the subscriber, the retry policy will not be invoked.
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.rxjava.rabbitmq

    Methods in io.vertx.rxjava.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)` Add a Confirm Listener to the channel.
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler)` Acknowledge one or several received messages.
    `void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQPublisher.`publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Long>> resultHandler)` Publish a message and complete when publish confirm has returned.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`restartConnect(int attempts, Handler<AsyncResult<Void>> resultHandler)` restart the rabbitMQ connect.
    `Single<Void>` | RabbitMQClient.`rxBasicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.rxjava.redis.client

    Methods in io.vertx.rxjava.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Access List Control commands.
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Append a value to a key.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Sent by cluster clients after an -ASK redirect.
    `RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Authenticate to the server.
    `Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisAPI` | RedisAPI.`bfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.ADD.
    `RedisAPI` | RedisAPI.`bfCard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.CARD.
    `RedisAPI` | RedisAPI.`bfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.DEBUG.
    `RedisAPI` | RedisAPI.`bfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.EXISTS.
    `RedisAPI` | RedisAPI.`bfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INFO.
    `RedisAPI` | RedisAPI.`bfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INSERT.
    `RedisAPI` | RedisAPI.`bfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.LOADCHUNK.
    `RedisAPI` | RedisAPI.`bfMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MADD.
    `RedisAPI` | RedisAPI.`bfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MEXISTS.
    `RedisAPI` | RedisAPI.`bfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.RESERVE.
    `RedisAPI` | RedisAPI.`bfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.SCANDUMP.
    `RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Asynchronously rewrite the append-only file.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Asynchronously save the dataset to disk.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Count set bits in a string.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Perform bitwise operations between strings.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Find first bit set or clear in a string.
    `RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list, or block until one is available.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first element in a list, or block until one is available.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last element in a list, or block until one is available.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set or block until one is available.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | RedisAPI.`cfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADD.
    `RedisAPI` | RedisAPI.`cfAddnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADDNX.
    `RedisAPI` | RedisAPI.`cfCompact(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COMPACT.
    `RedisAPI` | RedisAPI.`cfCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COUNT.
    `RedisAPI` | RedisAPI.`cfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEBUG.
    `RedisAPI` | RedisAPI.`cfDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEL.
    `RedisAPI` | RedisAPI.`cfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.EXISTS.
    `RedisAPI` | RedisAPI.`cfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INFO.
    `RedisAPI` | RedisAPI.`cfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERT.
    `RedisAPI` | RedisAPI.`cfInsertnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERTNX.
    `RedisAPI` | RedisAPI.`cfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.LOADCHUNK.
    `RedisAPI` | RedisAPI.`cfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.MEXISTS.
    `RedisAPI` | RedisAPI.`cfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.RESERVE.
    `RedisAPI` | RedisAPI.`cfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.SCANDUMP.
    `RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` A container for client connection commands.
    `RedisConnection` | RedisConnection.`close(Handler<AsyncResult<Void>> onClose)` Closes the connection or returns to the pool.
    `RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` A container for cluster commands.
    `RedisAPI` | RedisAPI.`cmsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INCRBY.
    `RedisAPI` | RedisAPI.`cmsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INFO.
    `RedisAPI` | RedisAPI.`cmsInitbydim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYDIM.
    `RedisAPI` | RedisAPI.`cmsInitbyprob(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYPROB.
    `RedisAPI` | RedisAPI.`cmsMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.MERGE.
    `RedisAPI` | RedisAPI.`cmsQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.QUERY.
    `RedisAPI` | RedisAPI.`command(List<String> args, Handler<AsyncResult<Response>> handler)` Get array of Redis command details.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` A container for server configuration commands.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Copy a key.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Return the number of keys in the selected database.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` A container for debugging commands.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by one.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by the given number.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Discard all commands issued after MULTI.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Echo the given string.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)`
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)`
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Execute all commands issued after MULTI.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Determine if a key exists.
    `RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in seconds.
    `RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp.
    `RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key.
    `RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Start a coordinated failover between this server and one of its replicas.
    `RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a function.
    `RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a read-only function.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from all databases.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from the current database.
    `RedisAPI` | RedisAPI.`ftAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ADD.
    `RedisAPI` | RedisAPI.`ftAggregate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.AGGREGATE.
    `RedisAPI` | RedisAPI.`ftAliasadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASADD.
    `RedisAPI` | RedisAPI.`ftAliasaddifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASADDIFNX.
    `RedisAPI` | RedisAPI.`ftAliasdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASDEL.
    `RedisAPI` | RedisAPI.`ftAliasdelifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASDELIFX.
    `RedisAPI` | RedisAPI.`ftAliasupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASUPDATE.
    `RedisAPI` | RedisAPI.`ftAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALTER.
    `RedisAPI` | RedisAPI.`ftAlterifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALTERIFNX.
    `RedisAPI` | RedisAPI.`ftConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CONFIG.
    `RedisAPI` | RedisAPI.`ftCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CREATE.
    `RedisAPI` | RedisAPI.`ftCreateifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._CREATEIFNX.
    `RedisAPI` | RedisAPI.`ftCursor(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CURSOR.
    `RedisAPI` | RedisAPI.`ftDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEBUG.
    `RedisAPI` | RedisAPI.`ftDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEL.
    `RedisAPI` | RedisAPI.`ftDictadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTADD.
    `RedisAPI` | RedisAPI.`ftDictdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDEL.
    `RedisAPI` | RedisAPI.`ftDictdump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDUMP.
    `RedisAPI` | RedisAPI.`ftDrop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROP.
    `RedisAPI` | RedisAPI.`ftDropifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPIFX.
    `RedisAPI` | RedisAPI.`ftDropindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROPINDEX.
    `RedisAPI` | RedisAPI.`ftDropindexifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPINDEXIFX.
    `RedisAPI` | RedisAPI.`ftExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAIN.
    `RedisAPI` | RedisAPI.`ftExplaincli(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAINCLI.
    `RedisAPI` | RedisAPI.`ftGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.GET.
    `RedisAPI` | RedisAPI.`ftInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.INFO.
    `RedisAPI` | RedisAPI.`ftList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._LIST.
    `RedisAPI` | RedisAPI.`ftMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.MGET.
    `RedisAPI` | RedisAPI.`ftProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.PROFILE.
    `RedisAPI` | RedisAPI.`ftSafeadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SAFEADD.
    `RedisAPI` | RedisAPI.`ftSearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SEARCH.
    `RedisAPI` | RedisAPI.`ftSpellcheck(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SPELLCHECK.
    `RedisAPI` | RedisAPI.`ftSugadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGADD.
    `RedisAPI` | RedisAPI.`ftSugdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGDEL.
    `RedisAPI` | RedisAPI.`ftSugget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGGET.
    `RedisAPI` | RedisAPI.`ftSuglen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGLEN.
    `RedisAPI` | RedisAPI.`ftSynadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNADD.
    `RedisAPI` | RedisAPI.`ftSyndump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNDUMP.
    `RedisAPI` | RedisAPI.`ftSynupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNUPDATE.
    `RedisAPI` | RedisAPI.`ftTagvals(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.TAGVALS.
    `RedisAPI` | RedisAPI.`function(List<String> args, Handler<AsyncResult<Response>> handler)` A container for function commands.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the distance between two members of a geospatial index.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Returns members of a geospatial index as standard geohash strings.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Returns longitude and latitude of members of a geospatial index.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUSBYMEMBER.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUS.
    `RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Returns the bit value at offset in the string value stored at key.
    `RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key and delete the key.
    `RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Get the value of a key and optionally set its expiration.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the string value of a key and return its old value.
    `RedisAPI` | RedisAPI.`graphBulk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.BULK.
    `RedisAPI` | RedisAPI.`graphConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.CONFIG.
    `RedisAPI` | RedisAPI.`graphDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DEBUG.
    `RedisAPI` | RedisAPI.`graphDelete(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DELETE.
    `RedisAPI` | RedisAPI.`graphExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.EXPLAIN.
    `RedisAPI` | RedisAPI.`graphList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.LIST.
    `RedisAPI` | RedisAPI.`graphProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.PROFILE.
    `RedisAPI` | RedisAPI.`graphQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.QUERY.
    `RedisAPI` | RedisAPI.`graphRoQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.RO_QUERY.
    `RedisAPI` | RedisAPI.`graphSlowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.SLOWLOG.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)`
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Delete one or more hash fields.
    `RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Handshake with Redis.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a hash field exists.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the value of a hash field.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields and values in a hash.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the integer value of a hash field by the given number.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the float value of a hash field by the given amount.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields in a hash.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of fields in a hash.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given hash fields.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple hash fields to multiple values.
    `RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random fields from a hash.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate hash fields and associated values.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a hash field.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of a hash field, only if the field does not exist.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the length of the value of a hash field.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Get all the values in a hash.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by one.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by the given amount.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the float value of a key by the given amount.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Get information and statistics about the server.
    `RedisAPI` | RedisAPI.`jsonArrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRAPPEND.
    `RedisAPI` | RedisAPI.`jsonArrindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINDEX.
    `RedisAPI` | RedisAPI.`jsonArrinsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINSERT.
    `RedisAPI` | RedisAPI.`jsonArrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRLEN.
    `RedisAPI` | RedisAPI.`jsonArrpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRPOP.
    `RedisAPI` | RedisAPI.`jsonArrtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRTRIM.
    `RedisAPI` | RedisAPI.`jsonClear(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.CLEAR.
    `RedisAPI` | RedisAPI.`jsonDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEBUG.
    `RedisAPI` | RedisAPI.`jsonDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEL.
    `RedisAPI` | RedisAPI.`jsonForget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.FORGET.
    `RedisAPI` | RedisAPI.`jsonGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.GET.
    `RedisAPI` | RedisAPI.`jsonMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.MGET.
    `RedisAPI` | RedisAPI.`jsonNumincrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMINCRBY.
    `RedisAPI` | RedisAPI.`jsonNummultby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMMULTBY.
    `RedisAPI` | RedisAPI.`jsonNumpowby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMPOWBY.
    `RedisAPI` | RedisAPI.`jsonObjkeys(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJKEYS.
    `RedisAPI` | RedisAPI.`jsonObjlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJLEN.
    `RedisAPI` | RedisAPI.`jsonResp(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.RESP.
    `RedisAPI` | RedisAPI.`jsonSet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.SET.
    `RedisAPI` | RedisAPI.`jsonStrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRAPPEND.
    `RedisAPI` | RedisAPI.`jsonStrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRLEN.
    `RedisAPI` | RedisAPI.`jsonToggle(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TOGGLE.
    `RedisAPI` | RedisAPI.`jsonType(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TYPE.
    `RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Find all keys matching the given pattern.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Get the UNIX time stamp of the last successful save to disk.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` A container for latency diagnostics commands.
    `RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Find longest common substring.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get an element from a list by its index.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Insert an element before or after another element in a list.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of a list.
    `RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it.
    `RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Display some computer art and the Redis version.
    `RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first elements in a list.
    `RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Return the index of matching elements on a list.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend one or multiple elements to a list.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend an element to a list, only if the list exists.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a range of elements from a list.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove elements from a list.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of an element in a list by its index.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Trim a list to the specified range.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` A container for memory diagnostics commands.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given keys.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` A container for module commands.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Listen for all requests received by the server in real time.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Move a key to another database.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values, only if none of the keys exist.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Mark the start of a transaction block.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` A container for object introspection commands.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Remove the expiration from a key.
    `RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in milliseconds.
    `RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key in milliseconds.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Internal commands for debugging HyperLogLog values.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` An internal command for testing HyperLogLog values.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Ping the server.
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration in milliseconds of a key.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to channels matching the given patterns.
    `RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in milliseconds.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a channel.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Pub/Sub commands.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to channels matching the given patterns.
    `RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Close the connection.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Return a random key from the keyspace.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Enables read queries for a connection to a cluster replica node.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Disables read queries for a connection to a cluster replica node.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key, only if the new key does not exist.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for configuring the replication stream.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Reset the connection.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for migrating keys in a cluster.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Return the role of the instance in the context of replication.
    `RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last elements in a list.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Remove the last element in a list, prepend it to another list and return it.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Append one or multiple elements to a list.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Append an element to a list, only if the list exists.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a set.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate the keys space.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a set.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Lua scripts management commands.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Change the selected database for the current connection.
    `Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a key.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Sets or clears the bit at offset in the string value stored at key.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration of a key.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the value of a key, only if the key does not exist.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Overwrite part of a string at key starting at the specified offset.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk and then shut down the server.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets.
    `RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and return the cardinality of the result.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a given value is a member of a set.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` A container for slow log commands.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Get all the members in a set.
    `RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the membership associated with the given elements for a set.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Move a member from one set to another.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return one or multiple random members from a set.
    `RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a shard channel.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random members from a set.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a set.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate Set elements.
    `RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given shard channels.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of the value stored in a key.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given channels.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets and store the resulting set in a key.
    `RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given shard channels.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Swaps two Redis databases.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | RedisAPI.`tdigestAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.ADD.
    `RedisAPI` | RedisAPI.`tdigestByrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYRANK.
    `RedisAPI` | RedisAPI.`tdigestByrevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYREVRANK.
    `RedisAPI` | RedisAPI.`tdigestCdf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CDF.
    `RedisAPI` | RedisAPI.`tdigestCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CREATE.
    `RedisAPI` | RedisAPI.`tdigestInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.INFO.
    `RedisAPI` | RedisAPI.`tdigestMax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MAX.
    `RedisAPI` | RedisAPI.`tdigestMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MERGE.
    `RedisAPI` | RedisAPI.`tdigestMin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MIN.
    `RedisAPI` | RedisAPI.`tdigestQuantile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.QUANTILE.
    `RedisAPI` | RedisAPI.`tdigestRank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RANK.
    `RedisAPI` | RedisAPI.`tdigestReset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RESET.
    `RedisAPI` | RedisAPI.`tdigestRevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.REVRANK.
    `RedisAPI` | RedisAPI.`tdigestTrimmedMean(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.TRIMMED_MEAN.
    `RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Return the current server time.
    `RedisAPI` | RedisAPI.`timeseriesClusterset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSET.
    `RedisAPI` | RedisAPI.`timeseriesClustersetfromshard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `RedisAPI` | RedisAPI.`timeseriesHello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.HELLO.
    `RedisAPI` | RedisAPI.`timeseriesInfocluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INFOCLUSTER.
    `RedisAPI` | RedisAPI.`timeseriesInnercommunication(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `RedisAPI` | RedisAPI.`timeseriesNetworktest(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.NETWORKTEST.
    `RedisAPI` | RedisAPI.`timeseriesRefreshcluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.REFRESHCLUSTER.
    `RedisAPI` | RedisAPI.`topkAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.ADD.
    `RedisAPI` | RedisAPI.`topkCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.COUNT.
    `RedisAPI` | RedisAPI.`topkIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INCRBY.
    `RedisAPI` | RedisAPI.`topkInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INFO.
    `RedisAPI` | RedisAPI.`topkList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.LIST.
    `RedisAPI` | RedisAPI.`topkQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.QUERY.
    `RedisAPI` | RedisAPI.`topkReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.RESERVE.
    `RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Alters the last access time of a key(s).
    `RedisAPI` | RedisAPI.`tsAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ADD.
    `RedisAPI` | RedisAPI.`tsAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ALTER.
    `RedisAPI` | RedisAPI.`tsCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATE.
    `RedisAPI` | RedisAPI.`tsCreaterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATERULE.
    `RedisAPI` | RedisAPI.`tsDecrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DECRBY.
    `RedisAPI` | RedisAPI.`tsDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DEL.
    `RedisAPI` | RedisAPI.`tsDeleterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DELETERULE.
    `RedisAPI` | RedisAPI.`tsGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.GET.
    `RedisAPI` | RedisAPI.`tsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INCRBY.
    `RedisAPI` | RedisAPI.`tsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INFO.
    `RedisAPI` | RedisAPI.`tsMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MADD.
    `RedisAPI` | RedisAPI.`tsMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MGET.
    `RedisAPI` | RedisAPI.`tsMrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MRANGE.
    `RedisAPI` | RedisAPI.`tsMrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MREVRANGE.
    `RedisAPI` | RedisAPI.`tsQueryindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.QUERYINDEX.
    `RedisAPI` | RedisAPI.`tsRange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.RANGE.
    `RedisAPI` | RedisAPI.`tsRevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.REVRANGE.
    `RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in seconds.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Determine the type stored at key.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key asynchronously in another thread.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given channels.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Forget about all watched keys.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Appends a new entry to a stream.
    `RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Removes the specified entries from the stream.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` A container for consumer groups commands.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` A container for stream introspection commands.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Return the number of entries in a stream.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for replicating stream values.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Trims the stream to (approximately if '~' is passed) a certain size.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a sorted set, or update its score if it already exists.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a sorted set.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the members in a sorted set with scores within the given values.
    `RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets.
    `RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the score of a member in a sorted set.
    `RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets.
    `RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and return the cardinality of the result.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the number of members in a sorted set between a given lexicographical range.
    `RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set.
    `RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Get the score associated with the given members in a sorted set.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the highest scores in a sorted set.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the lowest scores in a sorted set.
    `RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random elements from a sorted set.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score.
    `RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Store a range of members from sorted set into another key.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a sorted set.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set between the given lexicographical range.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given indexes.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given scores.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate sorted sets elements and associated scores.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the score associated with the given member in a sorted set.
    `RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key.

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery

    Methods in io.vertx.rxjava.servicediscovery with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(JsonObject filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(String id, Handler<AsyncResult<Record>> resultHandler)` Looks up for a single record by its registration `id`.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(JsonObject filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery bridge.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery service importer.
    `void` | ServiceDiscovery.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServiceDiscovery.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates the given record.

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery.spi

    Methods in io.vertx.rxjava.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceImporter.`close(Handler<Void> closeHandler)` Closes the importer
    `void` | ServiceExporter.`close(Handler<Void> closeHandler)` Close the exporter
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServicePublisher.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServicePublisher.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates an existing record.

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery.types

    Methods in io.vertx.rxjava.servicediscovery.types with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<Redis>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `Redis`.
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .

  - ### Uses of Handler in io.vertx.rxjava.sqlclient

    Methods in io.vertx.rxjava.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SqlConnection.`begin(Handler<AsyncResult<Transaction>> handler)` Begin a transaction and returns a `Transaction` for controlling and tracking this transaction.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | SqlConnection.`close(Handler<AsyncResult<Void>> handler)` Close the current connection after all the pending commands have been processed.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a `completionHandler` called when the cursor has been released.
    `void` | Pool.`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
    `void` | SqlClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release the associated resources.
    `void` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but notifies the `completionHandler` when it's closed.
    `SqlConnection` | SqlConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` with an handler to be notified when the transaction commit has completed
    `void` | Transaction.`completion(Handler<AsyncResult<Void>> handler)` Like `Transaction.completion(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a callback
    `Pool` | Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `RowStream<T>` | RowStream.`endHandler(Handler<Void> endHandler)`
    `RowStream<T>` | RowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SqlConnection` | SqlConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `void` | PreparedQuery.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | Query.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`execute(Tuple tuple, Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`executeBatch(List<Tuple> batch, Handler<AsyncResult<T>> handler)` Execute the query with a batch of tuples.
    `void` | Pool.`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
    `RowStream<T>` | RowStream.`handler(Handler<T> handler)`
    `void` | RowStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SqlConnection` | SqlConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.
    `SqlConnection` | SqlConnection.`prepare(String sql, PrepareOptions options, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.
    `void` | Cursor.`read(int count, Handler<AsyncResult<RowSet<Row>>> handler)` Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `void` | Transaction.`rollback(Handler<AsyncResult<Void>> handler)` Like `Transaction.rollback(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` with an handler to be notified when the transaction rollback has completed
    `ClientBuilder<C>` | ClientBuilder.`withConnectHandler(Handler<SqlConnection> handler)` Set a handler called when the pool has established a connection to the database.
    `<T> void` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Get a connection from the pool and execute the given `function`.
    `<T> void` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Like `Pool.withTransaction(java.util.function.Function<io.vertx.rxjava.sqlclient.SqlConnection, io.vertx.core.Future<T>>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.

  - ### Uses of Handler in io.vertx.rxjava3

    Methods in io.vertx.rxjava3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> SingleObserver<T>` | SingleHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> CompletableObserver` | CompletableHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> MaybeObserver<T>` | MaybeHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.

    Method parameters in io.vertx.rxjava3 with type arguments of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Completable` | CompletableHelper.`toCompletable(java.util.function.Consumer<Handler<AsyncResult<Void>>> handler)` Returns a `Completable` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Maybe<T>` | MaybeHelper.`toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)` Returns a `Maybe` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Single<T>` | SingleHelper.`toSingle(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)` Returns a `Single` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.

  - ### Uses of Handler in io.vertx.rxjava3.amqp

    Methods in io.vertx.rxjava3.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.cassandra

    Methods in io.vertx.rxjava3.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.circuitbreaker

    Classes in io.vertx.rxjava3.circuitbreaker that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HystrixMetricHandler` A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.

    Methods in io.vertx.rxjava3.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to close.
    `<T> Single<T>` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava3.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to open.
    `<T> Single<T>` | CircuitBreaker.`rxExecute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using a callback.

  - ### Uses of Handler in io.vertx.rxjava3.config

    Methods in io.vertx.rxjava3.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> handler)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.rxjava3.core

    Methods in io.vertx.rxjava3.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)` Deprecated.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)` Deprecated.
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
    `<T> Maybe<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)` Deprecated.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setPeriodic(long initialDelay, long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.

  - ### Uses of Handler in io.vertx.rxjava3.core.datagram

    Methods in io.vertx.rxjava3.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)` Deprecated.
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.core.eventbus

    Methods in io.vertx.rxjava3.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `<T> MessageConsumer<T>` | EventBus.`consumer(MessageConsumerOptions options, Handler<Message<T>> handler)` Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(io.vertx.core.eventbus.MessageConsumerOptions)` but the address won't be propagated across the cluster.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava3.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava3.core.eventbus.DeliveryContext<T>>)`

  - ### Uses of Handler in io.vertx.rxjava3.core.file

    Methods in io.vertx.rxjava3.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.core.http

    Methods in io.vertx.rxjava3.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava3.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`closeHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Deprecated.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a Continue handler has been set using this method, then the `handler` will be called.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `ClientWebSocket` | ClientWebSocket.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler(Handler<MultiMap> handler)` If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `ClientWebSocket` | ClientWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ClientWebSocket` | ClientWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ClientWebSocket` | ClientWebSocket.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler(Handler<HttpServerRequest> handler)` Set a `handler` for handling invalid requests.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`pongHandler(Handler<Buffer> handler)`
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `WebSocketBase` | WebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler(Handler<String> handler)`
    `WebSocketBase` | ServerWebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler(Handler<ServerWebSocketHandshake> handler)` Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.

  - ### Uses of Handler in io.vertx.rxjava3.core.net

    Methods in io.vertx.rxjava3.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.core.parsetools

    Classes in io.vertx.rxjava3.core.parsetools that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JsonParser` A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully.
    `class` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.rxjava3.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava3.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava3.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.rxjava3.core.streams

    Methods in io.vertx.rxjava3.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.

  - ### Uses of Handler in io.vertx.rxjava3.db2client

    Methods in io.vertx.rxjava3.db2client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static SqlClient` | DB2Builder.`client(Handler<ClientBuilder<SqlClient>> handler)` Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler(Handler<Void> handler)`
    `DB2Pool` | DB2Pool.`connectHandler(Handler<SqlConnection> handler)` Deprecated.
    `DB2Connection` | DB2Connection.`exceptionHandler(Handler<Throwable> handler)`
    `static Pool` | DB2Builder.`pool(Handler<ClientBuilder<Pool>> block)` Build a pool with the specified `block` argument.

  - ### Uses of Handler in io.vertx.rxjava3.ext.auth.oauth2

    Methods in io.vertx.rxjava3.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler(Handler<String> handler)` Handled to be called when a key (mentioned on a JWT) is missing from the current config.

  - ### Uses of Handler in io.vertx.rxjava3.ext.consul

    Methods in io.vertx.rxjava3.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`deletePolicy(String id, Handler<AsyncResult<Boolean>> resultHandler)` This endpoint deletes an ACL policy
    `ConsulClient` | ConsulClient.`getAclPolicies(Handler<AsyncResult<List<AclPolicy>>> resultHandler)` This endpoint lists all the ACL policies.
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.

  - ### Uses of Handler in io.vertx.rxjava3.ext.eventbus.bridge.tcp

    Methods in io.vertx.rxjava3.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`

  - ### Uses of Handler in io.vertx.rxjava3.ext.healthchecks

    Classes in io.vertx.rxjava3.ext.healthchecks that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HealthCheckHandler` A Vert.x Web handler on which you register health check procedure.

    Methods in io.vertx.rxjava3.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.rxjava3.ext.shell

    Methods in io.vertx.rxjava3.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.

  - ### Uses of Handler in io.vertx.rxjava3.ext.shell.command

    Methods in io.vertx.rxjava3.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.

  - ### Uses of Handler in io.vertx.rxjava3.ext.shell.system

    Methods in io.vertx.rxjava3.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.rxjava3.ext.shell.term

    Classes in io.vertx.rxjava3.ext.shell.term that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJSTermHandler` NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

    Methods in io.vertx.rxjava3.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.rxjava3.ext.stomp

    Classes in io.vertx.rxjava3.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Methods in io.vertx.rxjava3.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the able to manage web socket connections.

    Methods in io.vertx.rxjava3.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`rxSubscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `Single<String>` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.rxjava3.ext.unit

    Methods in io.vertx.rxjava3.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.rxjava3.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.rxjava3.ext.unit.collect

    Methods in io.vertx.rxjava3.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.rxjava3.ext.unit.report

    Methods in io.vertx.rxjava3.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`

  - ### Uses of Handler in io.vertx.rxjava3.ext.web

    Classes in io.vertx.rxjava3.ext.web that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Router` A router receives request from an `HttpServer` and routes it to the first matching `Route` that it contains.

    Methods in io.vertx.rxjava3.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.rxjava3.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.

  - ### Uses of Handler in io.vertx.rxjava3.ext.web.api.contract

    Subinterfaces of Handler in io.vertx.rxjava3.ext.web.api.contract
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HTTPOperationRequestValidationHandler` Deprecated.

    Methods in io.vertx.rxjava3.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava3.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava3.ext.web.api.contract.openapi3

    Classes in io.vertx.rxjava3.ext.web.api.contract.openapi3 that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenAPI3RequestValidationHandler` Deprecated.

    Methods in io.vertx.rxjava3.ext.web.api.contract.openapi3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | OpenAPI3RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava3.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Deprecated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava3.ext.web.api.validation

    Subinterfaces of Handler in io.vertx.rxjava3.ext.web.api.validation
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ValidationHandler` Deprecated.

    Classes in io.vertx.rxjava3.ext.web.api.validation that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HTTPRequestValidationHandler` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava3.ext.web.handler

    Subinterfaces of Handler in io.vertx.rxjava3.ext.web.handler
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `AuthenticationHandler` Base interface for auth handlers.
    `interface` | `InputTrustHandler` Base input trust interface for handlers that verify the trust of the request.
    `interface` | `PlatformHandler` Base platform interface for handlers that provide functionality to the application platform.
    `interface` | `ProtocolUpgradeHandler` Base interface for handlers that perform protocol upgrades.
    `interface` | `SecurityPolicyHandler` Base security policy interface for handlers that provide HTTP security related headers.

    Classes in io.vertx.rxjava3.ext.web.handler that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `APIKeyHandler` An authentication handler that provides API Key support.
    `class` | `AuthorizationHandler` Base interface for authorization handlers that provide authorization support.
    `class` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `class` | `BodyHandler` A handler which gathers the entire request body and sets it on the .
    `class` | `ChainAuthHandler` An auth handler that chains to a sequence of handlers.
    `class` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `class` | `CSPHandler` Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
    `class` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `class` | `DigestAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `class` | `ErrorHandler` A pretty error handler for rendering error pages.
    `class` | `FaviconHandler` A handler that serves favicons.
    `class` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `class` | `HSTSHandler` HTTP Strict Transport Security (HSTS) RFC6797.
    `class` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `class` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `class` | `MethodOverrideHandler` NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.
    `class` | `MultiTenantHandler` A handler which selectively executes another handler if a precondition is met.
    `class` | `OAuth2AuthHandler` An auth handler that provides OAuth2 Authentication support.
    `class` | `OtpAuthHandler` An auth handler that provides One Time Password (Multi-Factor) Authentication support.
    `class` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `class` | `ResponseContentTypeHandler` A handler which sets the response content type automatically according to the best `Accept` header match.
    `class` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `class` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `class` | `SimpleAuthenticationHandler` A user customizable authentication handler.
    `class` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `class` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `class` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `class` | `WebAuthnHandler` An auth handler that provides FIDO2 WebAuthN Relay Party support.
    `class` | `XFrameHandler` The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a ``, ``