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

- Packages that use AsyncResult
  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.shareddata |
  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.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.term |
  io.vertx.ext.sql |
  io.vertx.ext.stomp |
  io.vertx.ext.sync |
  io.vertx.ext.unit |
  io.vertx.ext.web |
  io.vertx.ext.web.api.contract.openapi3 |
  io.vertx.ext.web.client |
  io.vertx.ext.web.client.spi |
  io.vertx.ext.web.codec |
  io.vertx.ext.web.common.template |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.openapi |
  io.vertx.ext.web.sstore |
  io.vertx.grpc |
  io.vertx.grpc.stub |
  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.groovy |
  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.term |
  io.vertx.reactivex.ext.sql |
  io.vertx.reactivex.ext.stomp |
  io.vertx.reactivex.ext.unit |
  io.vertx.reactivex.ext.unit.report |
  io.vertx.reactivex.ext.web |
  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.sockjs |
  io.vertx.reactivex.ext.web.openapi |
  io.vertx.reactivex.ext.web.sstore |
  io.vertx.reactivex.grpc.client |
  io.vertx.reactivex.grpc.common |
  io.vertx.reactivex.grpc.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.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.term |
  io.vertx.rxjava.ext.sql |
  io.vertx.rxjava.ext.stomp |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web |
  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.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.json.schema |
  io.vertx.rxjava.kafka.admin |
  io.vertx.rxjava.kafka.client.consumer |
  io.vertx.rxjava.kafka.client.producer |
  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.core.http |
  io.vertx.rxjava3.ext.consul |
  io.vertx.rxjava3.ext.unit |
  io.vertx.rxjava3.ext.web |
  io.vertx.rxjava3.pgclient |
  io.vertx.rxjava3.servicediscovery.types |
  io.vertx.servicediscovery |
  io.vertx.servicediscovery.backend.redis |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.types |
  io.vertx.serviceproxy |
  io.vertx.sqlclient |
  io.vertx.sqlclient.templates |

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

    Method parameters in io.vertx.amqp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `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.
    `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, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer 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.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from 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, AmqpSenderOptions options, 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.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.

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

    Method parameters in io.vertx.camel with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.cassandra

    Method parameters in io.vertx.cassandra with type arguments of type AsyncResult
    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.
    `<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.
    `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 AsyncResult in io.vertx.circuitbreaker

    Method parameters in io.vertx.circuitbreaker with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.`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.

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

    Method parameters in io.vertx.config with type arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.config.spi with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.config.spi.utils

    Method parameters in io.vertx.config.spi.utils with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.config.vault.client

    Methods in io.vertx.config.vault.client that return AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static <T> AsyncResult<T>` | VaultException.`toFailure(String message)`
    `static <T> AsyncResult<T>` | VaultException.`toFailure(String status, int code, String body)`
    `static <T> AsyncResult<T>` | VaultException.`toFailure(String message, Throwable cause)`

    Method parameters in io.vertx.config.vault.client with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.core

    Subinterfaces of AsyncResult in io.vertx.core
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `CompositeFuture` The composite future wraps a list of `futures`, it is useful when several futures needs to be coordinated.
    `interface` | `Future<T>` Represents the result of an action that may, or may not, have occurred yet.
    `interface` | `Timer` A timer task that can be used as a future.

    Methods in io.vertx.core that return AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `default <U> AsyncResult<U>` | AsyncResult.`map(java.util.function.Function<T,U> mapper)` Apply a `mapper` function on this async result.
    `default <V> AsyncResult<V>` | AsyncResult.`map(V value)` Map the result of this async result to a specific `value`.
    `default <V> AsyncResult<V>` | AsyncResult.`mapEmpty()` Map the result of this async result to `null`.
    `default AsyncResult<T>` | AsyncResult.`otherwise(java.util.function.Function<Throwable,T> mapper)` Apply a `mapper` function on this async result.
    `default AsyncResult<T>` | AsyncResult.`otherwise(T value)` Map the failure of this async result to a specific `value`.
    `default AsyncResult<T>` | AsyncResult.`otherwiseEmpty()` Map the failure of this async result to `null`.

    Methods in io.vertx.core with parameters of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `default void` | Promise.`handle(AsyncResult<T> asyncResult)` Succeed or fail this promise with the `AsyncResult` event.

    Method parameters in io.vertx.core with type arguments of type AsyncResult
    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` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `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.
    `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, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Callable, boolean)` 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> void` | WorkerExecutor.`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Callable)` but using a callback.
    `<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)`
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable, boolean)`
    `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` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated. instead use `WorkerExecutor.executeBlocking(Callable)`
    `CompositeFuture` | CompositeFuture.`onComplete(Handler<AsyncResult<CompositeFuture>> handler)`
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `<U> Future<U>` | Future.`transform(java.util.function.Function<AsyncResult<T>,Future<U>> mapper)` Transform this future with a `mapper` functions.
    `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 AsyncResult in io.vertx.core.datagram

    Method parameters in io.vertx.core.datagram with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.core.dns

    Method parameters in io.vertx.core.dns with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.core.eventbus

    Method parameters in io.vertx.core.eventbus with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `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 AsyncResult in io.vertx.core.file

    Method parameters in io.vertx.core.file with type arguments of type AsyncResult
    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)` Deletes the file represented by the specified `path`, asynchronously.
    `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.
    `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 AsyncResult in io.vertx.core.http

    Method parameters in io.vertx.core.http with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `default HttpClientResponse` | HttpClientResponse.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpClientResponse.body()` but with an `handler` called when the operation completes
    `default HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body()` but with an `handler` called when the operation completes
    `void` | WebSocketClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `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).
    `default void` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `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
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `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(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(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 requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and 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.
    `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.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(Buffer)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String)` 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` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end()` 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` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` 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, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(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
    `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
    `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.
    `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)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with no headers.
    `default HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, 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.
    `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.
    `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)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP 101 status code rejected when the `future` is succeeds with an HTTP status code different than 101 rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close()` method will try to accept the handshake and close the WebSocket afterward.
    `default void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Like `HttpConnection.shutdown(Handler)` but with a specific `timeout` in milliseconds.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `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).
    `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)`
    `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, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(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
    `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
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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 AsyncResult in io.vertx.core.net

    Method parameters in io.vertx.core.net with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `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`.
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end()`.
    `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 AsyncResult in io.vertx.core.shareddata

    Method parameters in io.vertx.core.shareddata with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.core.streams

    Method parameters in io.vertx.core.streams with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.db2client

    Method parameters in io.vertx.db2client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.ext.auth with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.authentication

    Method parameters in io.vertx.ext.auth.authentication with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.authorization

    Method parameters in io.vertx.ext.auth.authorization with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.jdbc

    Method parameters in io.vertx.ext.auth.jdbc with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.mongo

    Method parameters in io.vertx.ext.auth.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.oauth2

    Method parameters in io.vertx.ext.auth.oauth2 with type arguments of type AsyncResult
    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.
    `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 AsyncResult in io.vertx.ext.auth.oauth2.providers

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

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

    Method parameters in io.vertx.ext.auth.sqlclient with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.auth.webauthn

    Method parameters in io.vertx.ext.auth.webauthn with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.consul

    Method parameters in io.vertx.ext.consul with type arguments of type AsyncResult
    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.
    `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 AsyncResult in io.vertx.ext.eventbus.bridge.tcp

    Method parameters in io.vertx.ext.eventbus.bridge.tcp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `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 AsyncResult in io.vertx.ext.healthchecks

    Method parameters in io.vertx.ext.healthchecks with type arguments of type AsyncResult
    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(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.

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

    Method parameters in io.vertx.ext.httpservicefactory with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.mail

    Method parameters in io.vertx.ext.mail with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.mongo

    Method parameters in io.vertx.ext.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.reactivestreams

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

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

    Method parameters in io.vertx.ext.shell with type arguments of type AsyncResult
    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` | 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 AsyncResult in io.vertx.ext.shell.command

    Method parameters in io.vertx.ext.shell.command with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

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

    Method parameters in io.vertx.ext.shell.spi with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.shell.term

    Method parameters in io.vertx.ext.shell.term with type arguments of type AsyncResult
    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.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Bind the term server, the `TermServer.termHandler(Handler)` must be set before.

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

    Method parameters in io.vertx.ext.sql with type arguments of type AsyncResult
    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.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` 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.
    `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.
    `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.
    `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` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `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.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `default SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` 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.
    `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
    `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
    `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 AsyncResult in io.vertx.ext.stomp

    Method parameters in io.vertx.ext.stomp with type arguments of type AsyncResult
    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.
    `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.
    `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.`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.
    `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.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `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.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `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.
    `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, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `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.

  - ### Uses of AsyncResult in io.vertx.ext.sync

    Method parameters in io.vertx.ext.sync with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static <T> T` | Sync.`awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)` Deprecated. Invoke an asynchronous operation and obtain the result synchronous.
    `static <T> T` | Sync.`awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer, long timeout)` Deprecated. Invoke an asynchronous operation and obtain the result synchronous.

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

    Methods in io.vertx.ext.unit that return types with arguments of type AsyncResult
    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.

    Method parameters in io.vertx.ext.unit with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.

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

    Method parameters in io.vertx.ext.web with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `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)`
    `default RoutingContext` | RoutingContext.`json(Object json, Handler<AsyncResult<Void>> handler)` See `RoutingContext.json(Object)`.
    `default RoutingContext` | RoutingContext.`redirect(String url, Handler<AsyncResult<Void>> handler)` See `RoutingContext.redirect(String)`.

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

    Method parameters in io.vertx.ext.web.api.contract.openapi3 with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.ext.web.client

    Method parameters in io.vertx.ext.web.client with type arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.ext.web.client.spi with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.web.codec

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

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

    Method parameters in io.vertx.ext.web.common.template with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.ext.web.handler

    Method parameters in io.vertx.ext.web.handler with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.ext.web.handler.sockjs

    Method parameters in io.vertx.ext.web.handler.sockjs with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `default void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `default void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

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

    Method parameters in io.vertx.ext.web.openapi with type arguments of type AsyncResult
    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)`

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

    Method parameters in io.vertx.ext.web.sstore with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.grpc

    Method parameters in io.vertx.grpc with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `VertxServer` | VertxServer.`shutdown(Handler<AsyncResult<Void>> completionHandler)`
    `VertxServer` | VertxServer.`start(Handler<AsyncResult<Void>> completionHandler)`

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

    Method parameters in io.vertx.grpc.stub with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | GrpcWriteStream.`end(Handler<AsyncResult<Void>> hndlr)`
    `void` | GrpcWriteStream.`write(T data, Handler<AsyncResult<Void>> hndlr)`

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

    Method parameters in io.vertx.json.schema with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.json.schema.common

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

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

    Methods in io.vertx.junit5 that return types with arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.kafka.admin with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.kafka.client.consumer

    Method parameters in io.vertx.kafka.client.consumer with type arguments of type AsyncResult
    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.
    `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).
    `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.`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.`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.`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 AsyncResult in io.vertx.kafka.client.producer

    Method parameters in io.vertx.kafka.client.producer with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.lang.groovy

    Methods in io.vertx.lang.groovy with parameters of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | VertxExtensionModule.`asBoolean(AsyncResult self)` Coerces an `AsyncResult` as a boolean value according to Groovy-Truth.

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

    Method parameters in io.vertx.mqtt with type arguments of type AsyncResult
    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).
    `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
    `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
    `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, 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
    `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.`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

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

    Method parameters in io.vertx.mssqlclient with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.

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

    Method parameters in io.vertx.mysqlclient with type arguments of type AsyncResult
    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 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`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `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.
    `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 AsyncResult in io.vertx.pgclient

    Method parameters in io.vertx.pgclient with type arguments of type AsyncResult
    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 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`.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared statement using the given `sql` string.

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

    Method parameters in io.vertx.pgclient.pubsub with type arguments of type AsyncResult
    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.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.

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

    Method parameters in io.vertx.rabbitmq with type arguments of type AsyncResult
    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.
    `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.
    `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.
    `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.
    `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` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `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 AsyncResult in io.vertx.reactivex

    Method parameters in io.vertx.reactivex with type arguments of type AsyncResult
    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> MaybeObserver<T>` | MaybeHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.
    `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> 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 AsyncResult in io.vertx.reactivex.amqp

    Method parameters in io.vertx.reactivex.amqp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `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.
    `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.
    `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, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer 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.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from 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, AmqpSenderOptions options, 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.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `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
    `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 AsyncResult in io.vertx.reactivex.cassandra

    Method parameters in io.vertx.reactivex.cassandra with type arguments of type AsyncResult
    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.
    `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.
    `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 AsyncResult in io.vertx.reactivex.circuitbreaker

    Method parameters in io.vertx.reactivex.circuitbreaker with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `<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.`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.

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

    Method parameters in io.vertx.reactivex.config with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.

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

    Method parameters in io.vertx.reactivex.core with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxBuilder.`buildClustered(Handler<AsyncResult<Vertx>> handler)` Creates a clustered instance.
    `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
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `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.
    `<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, 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, 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(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(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, boolean ordered, 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` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Deprecated.
    `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 AsyncResult in io.vertx.reactivex.core.datagram

    Method parameters in io.vertx.reactivex.core.datagram with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.reactivex.core.dns

    Method parameters in io.vertx.reactivex.core.dns with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.core.eventbus

    Method parameters in io.vertx.reactivex.core.eventbus with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<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 AsyncResult in io.vertx.reactivex.core.file

    Method parameters in io.vertx.reactivex.core.file with type arguments of type AsyncResult
    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)` Deletes the file represented by the specified `path`, asynchronously.
    `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
    `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.
    `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 AsyncResult in io.vertx.reactivex.core.http

    Method parameters in io.vertx.reactivex.core.http with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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
    `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` | 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` | 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` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `void` | HttpClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `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` | 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` | 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` | 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` | 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` | 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` | 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` | 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
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `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(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(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 requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and 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(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket to the host and relative request URI and default port.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `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` | 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` | 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` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as 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` | 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` | 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` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `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, 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
    `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
    `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.
    `void` | HttpClientResponse.`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` | WebSocket.`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` | 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` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `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)` 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, String host, 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.
    `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.
    `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)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP status code rejected when the `future` is succeeds with an HTTP status code different than rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method will try to accept the handshake and close the WebSocket afterward.
    `void` | ServerWebSocket.`setHandshake(Single<Integer> future, Handler<AsyncResult<Integer>> handler)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP status code rejected when the `future` is succeeds with an HTTP status code different than rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method will try to accept the handshake and close the WebSocket afterward.
    `void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Like `HttpConnection.shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `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).
    `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.
    `void` | HttpServerResponse.`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` | 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` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as 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, 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
    `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
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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 AsyncResult in io.vertx.reactivex.core.net

    Method parameters in io.vertx.reactivex.core.net with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `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.
    `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`.
    `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>>)`.
    `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 AsyncResult in io.vertx.reactivex.core.parsetools

    Method parameters in io.vertx.reactivex.core.parsetools with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.

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

    Method parameters in io.vertx.reactivex.core.shareddata with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.core.streams

    Method parameters in io.vertx.reactivex.core.streams with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.reactivex.db2client

    Method parameters in io.vertx.reactivex.db2client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.reactivex.ext.auth with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.authentication

    Method parameters in io.vertx.reactivex.ext.auth.authentication with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.authorization

    Method parameters in io.vertx.reactivex.ext.auth.authorization with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.jdbc

    Method parameters in io.vertx.reactivex.ext.auth.jdbc with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.mongo

    Method parameters in io.vertx.reactivex.ext.auth.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.oauth2

    Method parameters in io.vertx.reactivex.ext.auth.oauth2 with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.reactivex.ext.auth.oauth2.providers

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

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

    Method parameters in io.vertx.reactivex.ext.auth.sqlclient with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.auth.webauthn

    Method parameters in io.vertx.reactivex.ext.auth.webauthn with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.consul

    Method parameters in io.vertx.reactivex.ext.consul with type arguments of type AsyncResult
    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.
    `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 AsyncResult in io.vertx.reactivex.ext.eventbus.bridge.tcp

    Method parameters in io.vertx.reactivex.ext.eventbus.bridge.tcp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `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 AsyncResult in io.vertx.reactivex.ext.healthchecks

    Method parameters in io.vertx.reactivex.ext.healthchecks with type arguments of type AsyncResult
    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(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.

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

    Method parameters in io.vertx.reactivex.ext.jdbc with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.mail

    Method parameters in io.vertx.reactivex.ext.mail with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.mongo

    Method parameters in io.vertx.reactivex.ext.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.shell

    Method parameters in io.vertx.reactivex.ext.shell with type arguments of type AsyncResult
    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` | 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 AsyncResult in io.vertx.reactivex.ext.shell.command

    Method parameters in io.vertx.reactivex.ext.shell.command with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

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

    Method parameters in io.vertx.reactivex.ext.shell.term with type arguments of type AsyncResult
    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.
    `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.

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

    Method parameters in io.vertx.reactivex.ext.sql with type arguments of type AsyncResult
    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.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` 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.
    `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.
    `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.
    `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` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `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.
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `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.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`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` | 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` | 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` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` 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.
    `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
    `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
    `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 AsyncResult in io.vertx.reactivex.ext.stomp

    Method parameters in io.vertx.reactivex.ext.stomp with type arguments of type AsyncResult
    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.
    `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.
    `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.`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.
    `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.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `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.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `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.
    `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, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `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.

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

    Methods in io.vertx.reactivex.ext.unit that return types with arguments of type AsyncResult
    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.

    Method parameters in io.vertx.reactivex.ext.unit with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.

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

    Method parameters in io.vertx.reactivex.ext.unit.report with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

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

    Method parameters in io.vertx.reactivex.ext.web with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `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>>)`
    `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>>)`.
    `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>>)`.

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

    Method parameters in io.vertx.reactivex.ext.web.api.contract.openapi3 with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.

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

    Method parameters in io.vertx.reactivex.ext.web.client with type arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.reactivex.ext.web.common.template with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.ext.web.handler

    Method parameters in io.vertx.reactivex.ext.web.handler with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.reactivex.ext.web.handler.sockjs

    Method parameters in io.vertx.reactivex.ext.web.handler.sockjs with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

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

    Method parameters in io.vertx.reactivex.ext.web.openapi with type arguments of type AsyncResult
    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

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

    Method parameters in io.vertx.reactivex.ext.web.sstore with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.grpc.client

    Method parameters in io.vertx.reactivex.grpc.client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `void` | GrpcClientResponse.`pipeTo(WriteStream<Resp> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcClientRequest.`write(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

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

    Method parameters in io.vertx.reactivex.grpc.common with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.reactivex.grpc.server

    Method parameters in io.vertx.reactivex.grpc.server with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.reactivex.json.schema

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

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

    Method parameters in io.vertx.reactivex.kafka.admin with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.kafka.client.consumer

    Method parameters in io.vertx.reactivex.kafka.client.consumer with type arguments of type AsyncResult
    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.
    `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).
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `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.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `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 AsyncResult in io.vertx.reactivex.kafka.client.producer

    Method parameters in io.vertx.reactivex.kafka.client.producer with type arguments of type AsyncResult
    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.
    `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.`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 AsyncResult in io.vertx.reactivex.mqtt

    Method parameters in io.vertx.reactivex.mqtt with type arguments of type AsyncResult
    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).
    `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
    `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
    `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, 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
    `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.`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

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

    Method parameters in io.vertx.reactivex.mssqlclient with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.reactivex.mysqlclient with type arguments of type AsyncResult
    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 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`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `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.
    `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 AsyncResult in io.vertx.reactivex.oracleclient

    Method parameters in io.vertx.reactivex.oracleclient with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static void` | OracleConnection.`connect(Vertx vertx, io.vertx.oracleclient.OracleConnectOptions connectOptions, Handler<AsyncResult<OracleConnection>> handler)` Create a connection to Oracle with the given `connectOptions`.
    `OracleConnection` | OracleConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.reactivex.pgclient with type arguments of type AsyncResult
    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 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`.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.reactivex.pgclient.pubsub with type arguments of type AsyncResult
    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.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

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

    Method parameters in io.vertx.reactivex.rabbitmq with type arguments of type AsyncResult
    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, 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.
    `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.
    `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.
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `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 AsyncResult in io.vertx.reactivex.redis.client

    Method parameters in io.vertx.reactivex.redis.client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ACL.
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command APPEND.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command ASKING.
    `RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command AUTH.
    `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)` Redis command BGREWRITEAOF.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BGSAVE.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITCOUNT.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD.
    `RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD_RO.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITOP.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITPOS.
    `RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Redis command BLMOVE.
    `RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLMPOP.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLPOP.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BRPOP.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command BRPOPLPUSH.
    `RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZMPOP.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMAX.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMIN.
    `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)` Redis command CLIENT.
    `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)` Redis command CLUSTER.
    `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)` Redis command COMMAND.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CONFIG.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command COPY.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command DBSIZE.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEBUG.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DECR.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command DECRBY.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEL.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command DISCARD.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DUMP.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ECHO.
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL.
    `RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL_RO.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA.
    `RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA_RO.
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command EXEC.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXISTS.
    `RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIRE.
    `RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIREAT.
    `RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command EXPIRETIME.
    `RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FAILOVER.
    `RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL.
    `RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL_RO.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHALL.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHDB.
    `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)` Redis command FUNCTION.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOADD.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEODIST.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOHASH.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOPOS.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER_RO.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS_RO.
    `RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCH.
    `RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCHSTORE.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GET.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETBIT.
    `RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GETDEL.
    `RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GETEX.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command GETRANGE.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETSET.
    `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.
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HDEL.
    `RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HELLO.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HEXISTS.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HGET.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HGETALL.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBY.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBYFLOAT.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HKEYS.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HLEN.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMGET.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMSET.
    `RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HRANDFIELD.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSCAN.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSET.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HSETNX.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HSTRLEN.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HVALS.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command INCR.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBY.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBYFLOAT.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command INFO.
    `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)` Redis command KEYS.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command LASTSAVE.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LATENCY.
    `RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LCS.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command LINDEX.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LINSERT.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command LLEN.
    `RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LMOVE.
    `RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LMPOP.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LOLWUT.
    `RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOP.
    `RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOS.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSH.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSHX.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LRANGE.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LREM.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LSET.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LTRIM.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MEMORY.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MGET.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MIGRATE.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MODULE.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command MONITOR.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command MOVE.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSET.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSETNX.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command MULTI.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command OBJECT.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PERSIST.
    `RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRE.
    `RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIREAT.
    `RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRETIME.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFADD.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFCOUNT.
    `RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PFDEBUG.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFMERGE.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command PFSELFTEST.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PING.
    `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)` Redis command PSETEX.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSUBSCRIBE.
    `RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSYNC.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PTTL.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PUBLISH.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUBSUB.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command QUIT.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command RANDOMKEY.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command READONLY.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command READWRITE.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAME.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAMENX.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command REPLCONF.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command REPLICAOF.
    `RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Redis command RESET.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE-ASKING.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command ROLE.
    `RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPOP.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RPOPLPUSH.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSH.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSHX.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SADD.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command SAVE.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCAN.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SCARD.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCRIPT.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFF.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFFSTORE.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SELECT.
    `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)` Redis command SET.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETBIT.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETEX.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SETNX.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETRANGE.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SHUTDOWN.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTER.
    `RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERCARD.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERSTORE.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SISMEMBER.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SLAVEOF.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SLOWLOG.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SMEMBERS.
    `RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SMISMEMBER.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SMOVE.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT.
    `RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT_RO.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SPOP.
    `RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SPUBLISH.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SRANDMEMBER.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SREM.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSCAN.
    `RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSUBSCRIBE.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command STRLEN.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUBSCRIBE.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SUBSTR.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNION.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNIONSTORE.
    `RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SWAPDB.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command SYNC.
    `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)` Redis command 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)` Redis command TOUCH.
    `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)` Redis command TTL.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command TYPE.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNLINK.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command UNWATCH.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command WAIT.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command WATCH.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XACK.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XADD.
    `RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XAUTOCLAIM.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XCLAIM.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XDEL.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XGROUP.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XINFO.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command XLEN.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XPENDING.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XRANGE.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREAD.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREADGROUP.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREVRANGE.
    `RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XSETID.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XTRIM.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZADD.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ZCARD.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZCOUNT.
    `RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFF.
    `RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFFSTORE.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZINCRBY.
    `RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTER.
    `RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERCARD.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERSTORE.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZLEXCOUNT.
    `RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMPOP.
    `RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMSCORE.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMAX.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMIN.
    `RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANDMEMBER.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGE.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGESTORE.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZRANK.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREM.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYRANK.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGE.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANK.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZSCAN.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZSCORE.
    `RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNION.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNIONSTORE.

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

    Method parameters in io.vertx.reactivex.servicediscovery with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.servicediscovery.spi

    Method parameters in io.vertx.reactivex.servicediscovery.spi with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.reactivex.servicediscovery.types

    Method parameters in io.vertx.reactivex.servicediscovery.types with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.reactivex.sqlclient

    Method parameters in io.vertx.reactivex.sqlclient with type arguments of type AsyncResult
    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` | 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.
    `void` | SqlConnection.`close(Handler<AsyncResult<Void>> handler)` Close the current connection after all the pending commands have been processed.
    `void` | Pool.`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | SqlClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release the associated resources.
    `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` | 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
    `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.
    `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
    `<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 AsyncResult in io.vertx.reactivex.sqlclient.templates

    Method parameters in io.vertx.reactivex.sqlclient.templates with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.redis.client

    Method parameters in io.vertx.redis.client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `default RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ACL.
    `default RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command APPEND.
    `default RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command ASKING.
    `default RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command AUTH.
    `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)` Redis command BGREWRITEAOF.
    `default RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BGSAVE.
    `default RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITCOUNT.
    `default RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD.
    `default RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD_RO.
    `default RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITOP.
    `default RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITPOS.
    `default RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Redis command BLMOVE.
    `default RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLMPOP.
    `default RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLPOP.
    `default RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BRPOP.
    `default RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command BRPOPLPUSH.
    `default RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZMPOP.
    `default RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMAX.
    `default RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMIN.
    `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)` Redis command CLIENT.
    `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)` Redis command CLUSTER.
    `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)` Redis command COMMAND.
    `default RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CONFIG.
    `default Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `default RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command COPY.
    `default RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command DBSIZE.
    `default RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEBUG.
    `default RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DECR.
    `default RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command DECRBY.
    `default RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEL.
    `default RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command DISCARD.
    `default RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DUMP.
    `default RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ECHO.
    `default RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL.
    `default RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL_RO.
    `default RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA.
    `default RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA_RO.
    `default RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command EXEC.
    `default RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXISTS.
    `default RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIRE.
    `default RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIREAT.
    `default RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command EXPIRETIME.
    `default RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FAILOVER.
    `default RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL.
    `default RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL_RO.
    `default RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHALL.
    `default RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHDB.
    `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)` Redis command FUNCTION.
    `default RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOADD.
    `default RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEODIST.
    `default RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOHASH.
    `default RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOPOS.
    `default RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS.
    `default RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER.
    `default RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER_RO.
    `default RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS_RO.
    `default RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCH.
    `default RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCHSTORE.
    `default RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GET.
    `default RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETBIT.
    `default RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GETDEL.
    `default RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GETEX.
    `default RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command GETRANGE.
    `default RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETSET.
    `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.
    `default RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HDEL.
    `default RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HELLO.
    `default RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HEXISTS.
    `default RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HGET.
    `default RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HGETALL.
    `default RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBY.
    `default RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBYFLOAT.
    `default RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HKEYS.
    `default RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HLEN.
    `default RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMGET.
    `default RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMSET.
    `default RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HRANDFIELD.
    `default RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSCAN.
    `default RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSET.
    `default RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HSETNX.
    `default RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HSTRLEN.
    `default RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HVALS.
    `default RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command INCR.
    `default RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBY.
    `default RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBYFLOAT.
    `default RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command INFO.
    `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)` Redis command KEYS.
    `default RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command LASTSAVE.
    `default RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LATENCY.
    `default RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LCS.
    `default RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command LINDEX.
    `default RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LINSERT.
    `default RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command LLEN.
    `default RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LMOVE.
    `default RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LMPOP.
    `default RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LOLWUT.
    `default RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOP.
    `default RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOS.
    `default RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSH.
    `default RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSHX.
    `default RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LRANGE.
    `default RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LREM.
    `default RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LSET.
    `default RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LTRIM.
    `default RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MEMORY.
    `default RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MGET.
    `default RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MIGRATE.
    `default RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MODULE.
    `default RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command MONITOR.
    `default RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command MOVE.
    `default RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSET.
    `default RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSETNX.
    `default RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command MULTI.
    `default RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command OBJECT.
    `default RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PERSIST.
    `default RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRE.
    `default RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIREAT.
    `default RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRETIME.
    `default RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFADD.
    `default RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFCOUNT.
    `default RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PFDEBUG.
    `default RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFMERGE.
    `default RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command PFSELFTEST.
    `default RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PING.
    `default RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command PSETEX.
    `default RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSUBSCRIBE.
    `default RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSYNC.
    `default RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PTTL.
    `default RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PUBLISH.
    `default RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUBSUB.
    `default RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUNSUBSCRIBE.
    `default RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command QUIT.
    `default RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command RANDOMKEY.
    `default RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command READONLY.
    `default RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command READWRITE.
    `default RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAME.
    `default RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAMENX.
    `default RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command REPLCONF.
    `default RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command REPLICAOF.
    `default RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Redis command RESET.
    `default RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE.
    `default RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE-ASKING.
    `default RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command ROLE.
    `default RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPOP.
    `default RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RPOPLPUSH.
    `default RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSH.
    `default RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSHX.
    `default RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SADD.
    `default RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command SAVE.
    `default RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCAN.
    `default RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SCARD.
    `default RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCRIPT.
    `default RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFF.
    `default RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFFSTORE.
    `default RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SELECT.
    `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)` Redis command SET.
    `default RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETBIT.
    `default RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETEX.
    `default RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SETNX.
    `default RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETRANGE.
    `default RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SHUTDOWN.
    `default RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTER.
    `default RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERCARD.
    `default RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERSTORE.
    `default RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SISMEMBER.
    `default RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SLAVEOF.
    `default RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SLOWLOG.
    `default RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SMEMBERS.
    `default RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SMISMEMBER.
    `default RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SMOVE.
    `default RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT.
    `default RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT_RO.
    `default RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SPOP.
    `default RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SPUBLISH.
    `default RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SRANDMEMBER.
    `default RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SREM.
    `default RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSCAN.
    `default RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSUBSCRIBE.
    `default RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command STRLEN.
    `default RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUBSCRIBE.
    `default RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SUBSTR.
    `default RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNION.
    `default RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNIONSTORE.
    `default RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNSUBSCRIBE.
    `default RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SWAPDB.
    `default RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command SYNC.
    `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)` Redis command 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)` Redis command TOUCH.
    `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)` Redis command TTL.
    `default RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command TYPE.
    `default RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNLINK.
    `default RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNSUBSCRIBE.
    `default RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command UNWATCH.
    `default RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command WAIT.
    `default RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command WATCH.
    `default RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XACK.
    `default RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XADD.
    `default RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XAUTOCLAIM.
    `default RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XCLAIM.
    `default RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XDEL.
    `default RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XGROUP.
    `default RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XINFO.
    `default RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command XLEN.
    `default RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XPENDING.
    `default RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XRANGE.
    `default RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREAD.
    `default RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREADGROUP.
    `default RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREVRANGE.
    `default RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XSETID.
    `default RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XTRIM.
    `default RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZADD.
    `default RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ZCARD.
    `default RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZCOUNT.
    `default RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFF.
    `default RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFFSTORE.
    `default RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZINCRBY.
    `default RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTER.
    `default RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERCARD.
    `default RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERSTORE.
    `default RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZLEXCOUNT.
    `default RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMPOP.
    `default RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMSCORE.
    `default RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMAX.
    `default RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMIN.
    `default RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANDMEMBER.
    `default RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGE.
    `default RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYLEX.
    `default RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYSCORE.
    `default RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGESTORE.
    `default RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZRANK.
    `default RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREM.
    `default RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYLEX.
    `default RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYRANK.
    `default RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYSCORE.
    `default RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGE.
    `default RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYLEX.
    `default RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYSCORE.
    `default RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANK.
    `default RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZSCAN.
    `default RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZSCORE.
    `default RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNION.
    `default RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNIONSTORE.

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

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

    Methods in io.vertx.rx.java that return types with arguments of type AsyncResult
    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<AsyncResult<T>>` | ObservableFuture.`toHandler()`

    Methods in io.vertx.rx.java with parameters of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | HandlerAdapter.`dispatch(AsyncResult<T> event)`
    `void` | HandlerAdapter.`handle(AsyncResult<T> event)`

    Method parameters in io.vertx.rx.java with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult
    Constructor and Description
    `SingleOnSubscribeAdapter(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)`

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

    Method parameters in io.vertx.rxjava.amqp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `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.
    `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.
    `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, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer 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.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from 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, AmqpSenderOptions options, 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.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `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
    `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 AsyncResult in io.vertx.rxjava.cassandra

    Method parameters in io.vertx.rxjava.cassandra with type arguments of type AsyncResult
    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.
    `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.
    `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 AsyncResult in io.vertx.rxjava.circuitbreaker

    Method parameters in io.vertx.rxjava.circuitbreaker with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `<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.`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.

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

    Method parameters in io.vertx.rxjava.config with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.

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

    Method parameters in io.vertx.rxjava.core with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxBuilder.`buildClustered(Handler<AsyncResult<Vertx>> handler)` Creates a clustered instance.
    `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
    `void` | WorkerExecutor.`close(Handler<AsyncResult<Void>> handler)` Close the executor.
    `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.
    `<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, 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, 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(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(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, boolean ordered, 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` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Deprecated.
    `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 AsyncResult in io.vertx.rxjava.core.datagram

    Method parameters in io.vertx.rxjava.core.datagram with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.rxjava.core.dns

    Method parameters in io.vertx.rxjava.core.dns with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.core.eventbus

    Method parameters in io.vertx.rxjava.core.eventbus with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<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 AsyncResult in io.vertx.rxjava.core.file

    Method parameters in io.vertx.rxjava.core.file with type arguments of type AsyncResult
    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)` Deletes the file represented by the specified `path`, asynchronously.
    `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
    `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.
    `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 AsyncResult in io.vertx.rxjava.core.http

    Method parameters in io.vertx.rxjava.core.http with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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
    `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` | 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` | 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` | HttpConnection.`close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `void` | HttpClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `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` | 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` | 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` | 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` | 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` | 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` | 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` | 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
    `void` | HttpClientRequest.`connect(Handler<AsyncResult<HttpClientResponse>> handler)` Create an HTTP tunnel to the server.
    `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(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(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 requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket at the relative request URI using the default host and 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(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect this WebSocket to the host and relative request URI and default port.
    `void` | WebSocketClient.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | ClientWebSocket.`connect(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `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` | 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` | 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` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as 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` | 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` | 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` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `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, 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
    `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
    `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.
    `void` | HttpClientResponse.`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` | WebSocket.`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` | 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` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `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)` 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, String host, 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.
    `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.
    `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)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP status code rejected when the `future` is succeeds with an HTTP status code different than rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method will try to accept the handshake and close the WebSocket afterward.
    `void` | HttpConnection.`shutdown(Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `void` | HttpConnection.`shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Like `HttpConnection.shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
    `void` | HttpServerFileUpload.`streamToFileSystem(String filename, Handler<AsyncResult<Void>> handler)` Stream the content of this upload to the given file on storage.
    `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).
    `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.
    `void` | HttpServerResponse.`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` | 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` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as 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, 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
    `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
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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
    `ServerWebSocket` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `ClientWebSocket` | ClientWebSocket.`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 AsyncResult in io.vertx.rxjava.core.net

    Method parameters in io.vertx.rxjava.core.net with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetClient.`close(Handler<AsyncResult<Void>> handler)` Close the client.
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `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.
    `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`.
    `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>>)`.
    `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 AsyncResult in io.vertx.rxjava.core.parsetools

    Method parameters in io.vertx.rxjava.core.parsetools with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.

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

    Method parameters in io.vertx.rxjava.core.shareddata with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.core.streams

    Method parameters in io.vertx.rxjava.core.streams with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.rxjava.db2client

    Method parameters in io.vertx.rxjava.db2client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `DB2Connection` | DB2Connection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `DB2Connection` | DB2Connection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `DB2Connection` | DB2Connection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.rxjava.ext.auth with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.authentication

    Method parameters in io.vertx.rxjava.ext.auth.authentication with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.authorization

    Method parameters in io.vertx.rxjava.ext.auth.authorization with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.jdbc

    Method parameters in io.vertx.rxjava.ext.auth.jdbc with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.mongo

    Method parameters in io.vertx.rxjava.ext.auth.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.oauth2

    Method parameters in io.vertx.rxjava.ext.auth.oauth2 with type arguments of type AsyncResult
    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.`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 AsyncResult in io.vertx.rxjava.ext.auth.oauth2.providers

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

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

    Method parameters in io.vertx.rxjava.ext.auth.sqlclient with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.auth.webauthn

    Method parameters in io.vertx.rxjava.ext.auth.webauthn with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.consul

    Method parameters in io.vertx.rxjava.ext.consul with type arguments of type AsyncResult
    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.
    `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 AsyncResult in io.vertx.rxjava.ext.eventbus.bridge.tcp

    Method parameters in io.vertx.rxjava.ext.eventbus.bridge.tcp with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `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 AsyncResult in io.vertx.rxjava.ext.healthchecks

    Method parameters in io.vertx.rxjava.ext.healthchecks with type arguments of type AsyncResult
    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(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.

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

    Method parameters in io.vertx.rxjava.ext.jdbc with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.mail

    Method parameters in io.vertx.rxjava.ext.mail with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.mongo

    Method parameters in io.vertx.rxjava.ext.mongo with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.shell

    Method parameters in io.vertx.rxjava.ext.shell with type arguments of type AsyncResult
    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` | 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 AsyncResult in io.vertx.rxjava.ext.shell.command

    Method parameters in io.vertx.rxjava.ext.shell.command with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

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

    Method parameters in io.vertx.rxjava.ext.shell.term with type arguments of type AsyncResult
    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.
    `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.

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

    Method parameters in io.vertx.rxjava.ext.sql with type arguments of type AsyncResult
    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.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` 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.
    `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.
    `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.
    `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` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `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.
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `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.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`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` | 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` | 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` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `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.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` 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.
    `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
    `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
    `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 AsyncResult in io.vertx.rxjava.ext.stomp

    Method parameters in io.vertx.rxjava.ext.stomp with type arguments of type AsyncResult
    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.
    `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.
    `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.`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.
    `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.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<AsyncResult<Frame>> receiptHandler)` Disconnects the client.
    `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.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `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.
    `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, Handler<AsyncResult<String>> receiptHandler)` Subscribes to the given destination.
    `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.

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

    Methods in io.vertx.rxjava.ext.unit that return types with arguments of type AsyncResult
    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.

    Method parameters in io.vertx.rxjava.ext.unit with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.

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

    Method parameters in io.vertx.rxjava.ext.unit.report with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

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

    Method parameters in io.vertx.rxjava.ext.web with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.
    `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>>)`
    `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>>)`.
    `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>>)`.

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

    Method parameters in io.vertx.rxjava.ext.web.api.contract.openapi3 with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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.

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

    Method parameters in io.vertx.rxjava.ext.web.client with type arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.rxjava.ext.web.common.template with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.ext.web.handler

    Method parameters in io.vertx.rxjava.ext.web.handler with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.rxjava.ext.web.handler.sockjs

    Method parameters in io.vertx.rxjava.ext.web.handler.sockjs with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `void` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

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

    Method parameters in io.vertx.rxjava.ext.web.sstore with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.grpc.client

    Method parameters in io.vertx.rxjava.grpc.client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `void` | GrpcClientResponse.`pipeTo(WriteStream<Resp> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | GrpcClientRequest.`write(Req data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

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

    Method parameters in io.vertx.rxjava.grpc.common with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.rxjava.grpc.server

    Method parameters in io.vertx.rxjava.grpc.server with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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 AsyncResult in io.vertx.rxjava.json.schema

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

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

    Method parameters in io.vertx.rxjava.kafka.admin with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.kafka.client.consumer

    Method parameters in io.vertx.rxjava.kafka.client.consumer with type arguments of type AsyncResult
    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.
    `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).
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `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.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `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 AsyncResult in io.vertx.rxjava.kafka.client.producer

    Method parameters in io.vertx.rxjava.kafka.client.producer with type arguments of type AsyncResult
    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.
    `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.`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 AsyncResult in io.vertx.rxjava.mqtt

    Method parameters in io.vertx.rxjava.mqtt with type arguments of type AsyncResult
    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).
    `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
    `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
    `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, 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
    `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.`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

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

    Method parameters in io.vertx.rxjava.mssqlclient with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `MSSQLConnection` | MSSQLConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.rxjava.mysqlclient with type arguments of type AsyncResult
    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 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`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `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.
    `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 AsyncResult in io.vertx.rxjava.oracleclient

    Method parameters in io.vertx.rxjava.oracleclient with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static void` | OracleConnection.`connect(Vertx vertx, io.vertx.oracleclient.OracleConnectOptions connectOptions, Handler<AsyncResult<OracleConnection>> handler)` Create a connection to Oracle with the given `connectOptions`.
    `OracleConnection` | OracleConnection.`prepare(String s, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.rxjava.pgclient with type arguments of type AsyncResult
    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 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`.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

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

    Method parameters in io.vertx.rxjava.pgclient.pubsub with type arguments of type AsyncResult
    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.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

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

    Method parameters in io.vertx.rxjava.rabbitmq with type arguments of type AsyncResult
    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, 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.
    `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.
    `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.
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQPublisher.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ publisher.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQPublisher.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ publisher.
    `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 AsyncResult in io.vertx.rxjava.redis.client

    Method parameters in io.vertx.rxjava.redis.client with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`acl(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ACL.
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command APPEND.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command ASKING.
    `RedisAPI` | RedisAPI.`auth(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command AUTH.
    `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)` Redis command BGREWRITEAOF.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BGSAVE.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITCOUNT.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD.
    `RedisAPI` | RedisAPI.`bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD_RO.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITOP.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITPOS.
    `RedisAPI` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Redis command BLMOVE.
    `RedisAPI` | RedisAPI.`blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLMPOP.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLPOP.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BRPOP.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command BRPOPLPUSH.
    `RedisAPI` | RedisAPI.`bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZMPOP.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMAX.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMIN.
    `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)` Redis command CLIENT.
    `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)` Redis command CLUSTER.
    `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)` Redis command COMMAND.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CONFIG.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`copy(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command COPY.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command DBSIZE.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEBUG.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DECR.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command DECRBY.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEL.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command DISCARD.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DUMP.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ECHO.
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL.
    `RedisAPI` | RedisAPI.`evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL_RO.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA.
    `RedisAPI` | RedisAPI.`evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA_RO.
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command EXEC.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXISTS.
    `RedisAPI` | RedisAPI.`expire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIRE.
    `RedisAPI` | RedisAPI.`expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIREAT.
    `RedisAPI` | RedisAPI.`expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command EXPIRETIME.
    `RedisAPI` | RedisAPI.`failover(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FAILOVER.
    `RedisAPI` | RedisAPI.`fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL.
    `RedisAPI` | RedisAPI.`fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL_RO.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHALL.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHDB.
    `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)` Redis command FUNCTION.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOADD.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEODIST.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOHASH.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOPOS.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER_RO.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS_RO.
    `RedisAPI` | RedisAPI.`geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCH.
    `RedisAPI` | RedisAPI.`geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCHSTORE.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GET.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETBIT.
    `RedisAPI` | RedisAPI.`getdel(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GETDEL.
    `RedisAPI` | RedisAPI.`getex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GETEX.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command GETRANGE.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETSET.
    `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.
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HDEL.
    `RedisAPI` | RedisAPI.`hello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HELLO.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HEXISTS.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HGET.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HGETALL.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBY.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBYFLOAT.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HKEYS.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HLEN.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMGET.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMSET.
    `RedisAPI` | RedisAPI.`hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HRANDFIELD.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSCAN.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSET.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HSETNX.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HSTRLEN.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HVALS.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command INCR.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBY.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBYFLOAT.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command INFO.
    `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)` Redis command KEYS.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command LASTSAVE.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LATENCY.
    `RedisAPI` | RedisAPI.`lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LCS.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command LINDEX.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LINSERT.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command LLEN.
    `RedisAPI` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LMOVE.
    `RedisAPI` | RedisAPI.`lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LMPOP.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LOLWUT.
    `RedisAPI` | RedisAPI.`lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOP.
    `RedisAPI` | RedisAPI.`lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOS.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSH.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSHX.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LRANGE.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LREM.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LSET.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LTRIM.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MEMORY.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MGET.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MIGRATE.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MODULE.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command MONITOR.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command MOVE.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSET.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSETNX.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command MULTI.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command OBJECT.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PERSIST.
    `RedisAPI` | RedisAPI.`pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRE.
    `RedisAPI` | RedisAPI.`pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIREAT.
    `RedisAPI` | RedisAPI.`pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRETIME.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFADD.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFCOUNT.
    `RedisAPI` | RedisAPI.`pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PFDEBUG.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFMERGE.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command PFSELFTEST.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PING.
    `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)` Redis command PSETEX.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSUBSCRIBE.
    `RedisAPI` | RedisAPI.`psync(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSYNC.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PTTL.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PUBLISH.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUBSUB.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`quit(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command QUIT.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command RANDOMKEY.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command READONLY.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command READWRITE.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAME.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAMENX.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command REPLCONF.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command REPLICAOF.
    `RedisAPI` | RedisAPI.`reset(Handler<AsyncResult<Response>> handler)` Redis command RESET.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE-ASKING.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command ROLE.
    `RedisAPI` | RedisAPI.`rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPOP.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RPOPLPUSH.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSH.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSHX.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SADD.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command SAVE.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCAN.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SCARD.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCRIPT.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFF.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFFSTORE.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SELECT.
    `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)` Redis command SET.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETBIT.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETEX.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SETNX.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETRANGE.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SHUTDOWN.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTER.
    `RedisAPI` | RedisAPI.`sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERCARD.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERSTORE.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SISMEMBER.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SLAVEOF.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SLOWLOG.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SMEMBERS.
    `RedisAPI` | RedisAPI.`smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SMISMEMBER.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SMOVE.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT.
    `RedisAPI` | RedisAPI.`sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT_RO.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SPOP.
    `RedisAPI` | RedisAPI.`spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SPUBLISH.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SRANDMEMBER.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SREM.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSCAN.
    `RedisAPI` | RedisAPI.`ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSUBSCRIBE.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command STRLEN.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUBSCRIBE.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SUBSTR.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNION.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNIONSTORE.
    `RedisAPI` | RedisAPI.`sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SWAPDB.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command SYNC.
    `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)` Redis command 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)` Redis command TOUCH.
    `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)` Redis command TTL.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command TYPE.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNLINK.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNSUBSCRIBE.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command UNWATCH.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command WAIT.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command WATCH.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XACK.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XADD.
    `RedisAPI` | RedisAPI.`xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XAUTOCLAIM.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XCLAIM.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XDEL.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XGROUP.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XINFO.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command XLEN.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XPENDING.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XRANGE.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREAD.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREADGROUP.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREVRANGE.
    `RedisAPI` | RedisAPI.`xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XSETID.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XTRIM.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZADD.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ZCARD.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZCOUNT.
    `RedisAPI` | RedisAPI.`zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFF.
    `RedisAPI` | RedisAPI.`zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFFSTORE.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZINCRBY.
    `RedisAPI` | RedisAPI.`zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTER.
    `RedisAPI` | RedisAPI.`zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERCARD.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERSTORE.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZLEXCOUNT.
    `RedisAPI` | RedisAPI.`zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMPOP.
    `RedisAPI` | RedisAPI.`zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMSCORE.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMAX.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMIN.
    `RedisAPI` | RedisAPI.`zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANDMEMBER.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGE.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGESTORE.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZRANK.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREM.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYRANK.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGE.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYLEX.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYSCORE.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANK.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZSCAN.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZSCORE.
    `RedisAPI` | RedisAPI.`zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNION.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNIONSTORE.

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

    Method parameters in io.vertx.rxjava.servicediscovery with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.servicediscovery.spi

    Method parameters in io.vertx.rxjava.servicediscovery.spi with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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 AsyncResult in io.vertx.rxjava.servicediscovery.types

    Method parameters in io.vertx.rxjava.servicediscovery.types with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.rxjava.sqlclient

    Method parameters in io.vertx.rxjava.sqlclient with type arguments of type AsyncResult
    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` | 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.
    `void` | SqlConnection.`close(Handler<AsyncResult<Void>> handler)` Close the current connection after all the pending commands have been processed.
    `void` | Pool.`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | SqlClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release the associated resources.
    `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` | 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
    `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.
    `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
    `<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 AsyncResult in io.vertx.rxjava3

    Method parameters in io.vertx.rxjava3 with type arguments of type AsyncResult
    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> MaybeObserver<T>` | MaybeHelper.`toObserver(Handler<AsyncResult<T>> handler)` Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.
    `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> 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 AsyncResult in io.vertx.rxjava3.core.http

    Method parameters in io.vertx.rxjava3.core.http with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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

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

    Method parameters in io.vertx.rxjava3.ext.consul with type arguments of type AsyncResult
    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.

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

    Methods in io.vertx.rxjava3.ext.unit that return types with arguments of type AsyncResult
    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.

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

    Method parameters in io.vertx.rxjava3.ext.web with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addEndHandler(Handler<AsyncResult<Void>> handler)` Add an end handler for the request/response context.

  - ### Uses of AsyncResult in io.vertx.rxjava3.pgclient

    Method parameters in io.vertx.rxjava3.pgclient with type arguments of type AsyncResult
    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.

  - ### Uses of AsyncResult in io.vertx.rxjava3.servicediscovery.types

    Method parameters in io.vertx.rxjava3.servicediscovery.types with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `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).

  - ### Uses of AsyncResult in io.vertx.servicediscovery

    Method parameters in io.vertx.servicediscovery with type arguments of type AsyncResult
    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 AsyncResult in io.vertx.servicediscovery.backend.redis

    Method parameters in io.vertx.servicediscovery.backend.redis with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | RedisBackendService.`getRecord(String uuid, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`getRecords(Handler<AsyncResult<List<Record>>> resultHandler)`
    `void` | RedisBackendService.`remove(Record record, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`remove(String uuid, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`store(Record record, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`update(Record record, Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of AsyncResult in io.vertx.servicediscovery.spi

    Method parameters in io.vertx.servicediscovery.spi with type arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceDiscoveryBackend.`getRecord(String uuid, Handler<AsyncResult<Record>> resultHandler)` Get the record with the given uuid.
    `void` | ServiceDiscoveryBackend.`getRecords(Handler<AsyncResult<List<Record>>> resultHandler)` Gets all the records
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServiceDiscoveryBackend.`remove(Record record, Handler<AsyncResult<Record>> resultHandler)` Removes a record.
    `void` | ServiceDiscoveryBackend.`remove(String uuid, Handler<AsyncResult<Record>> resultHandler)` Removes a records based on its UUID.
    `void` | ServiceDiscoveryBackend.`store(Record record, Handler<AsyncResult<Record>> resultHandler)` Stores 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.
    `void` | ServiceDiscoveryBackend.`update(Record record, Handler<AsyncResult<Void>> resultHandler)` Updates a record

  - ### Uses of AsyncResult in io.vertx.servicediscovery.types

    Method parameters in io.vertx.servicediscovery.types with type arguments of type AsyncResult
    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 `HttpClient`.
    `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 `HttpClient`.
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `HttpClient`.
    `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 `HttpClient`.
    `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 `MessageConsumer`.
    `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 `MessageConsumer`.
    `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 <T> T` | EventBusService.`getProxy(ServiceDiscovery discovery, Class<T> itf, 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.`getProxy(ServiceDiscovery discovery, Class<T> itf, 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` | 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 `WebClient`.
    `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 `WebClient`.
    `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 `WebClient`.

  - ### Uses of AsyncResult in io.vertx.serviceproxy

    Methods in io.vertx.serviceproxy that return AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static <T> AsyncResult<T>` | ServiceException.`fail(int failureCode, String message)` Create a failed Future containing a ServiceException.
    `static <T> AsyncResult<T>` | ServiceException.`fail(int failureCode, String message, JsonObject debugInfo)` Create a failed Future containing a ServiceException.

    Methods in io.vertx.serviceproxy that return types with arguments of type AsyncResult
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<AsyncResult<T>>` | HelperUtils.`createHandler(Message msg, boolean includeDebugInfo)`
    `static Handler<AsyncResult<List<Character>>>` | HelperUtils.`createListCharHandler(Message msg, boolean includeDebugInfo)`
    `static <T> Handler<AsyncResult<List<T>>>` | HelperUtils.`createListHandler(Message msg, boolean includeDebugInfo)`
    `static Handler<AsyncResult<Map<String,Character>>>` | HelperUtils.`createMapCharHandler(Message msg, boolean includeDebugInfo)`
    `static <T> Handler<AsyncResult<Map<String,T>>>` | HelperUtils.`createMapHandler(Message msg, boolean includeDebugInfo)`
    `static Handler<AsyncResult<Set<Character>>>` | HelperUtils.`createSetCharHandler(Message msg, boolean includeDebugInfo)`
    `static <T> Handler<AsyncResult<Set<T>>>` | HelperUtils.`createSetHandler(Message msg, boolean includeDebugInfo)`

  - ### Uses of AsyncResult in io.vertx.sqlclient

    Method parameters in io.vertx.sqlclient with type arguments of type AsyncResult
    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` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close()` but notifies the `completionHandler` when it's closed.
    `void` | SqlConnection.`close(Handler<AsyncResult<Void>> handler)` Close the current connection after all the pending commands have been processed.
    `void` | Pool.`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | SqlClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release the associated resources.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close()` but with a `completionHandler` called when the cursor has been released.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit()` with an handler to be notified when the transaction commit has completed
    `void` | Transaction.`completion(Handler<AsyncResult<Void>> handler)` Like `Transaction.completion()` but with a callback
    `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.
    `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()` with an handler to be notified when the transaction rollback has completed
    `default <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`.
    `default <T> void` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `default <T> void` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Like `Pool.withTransaction(Function, Handler)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.

  - ### Uses of AsyncResult in io.vertx.sqlclient.templates

    Method parameters in io.vertx.sqlclient.templates with type arguments of type AsyncResult
    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`.

Copyright © 2024 Eclipse. All rights reserved.