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

- Packages that use Future
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.cassandra |
  io.vertx.circuitbreaker |
  io.vertx.config |
  io.vertx.config.consul |
  io.vertx.config.git |
  io.vertx.config.hocon |
  io.vertx.config.kubernetes |
  io.vertx.config.redis |
  io.vertx.config.spi |
  io.vertx.config.vault |
  io.vertx.config.yaml |
  io.vertx.config.zookeeper |
  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.otp.hotp |
  io.vertx.ext.auth.otp.totp |
  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.mail |
  io.vertx.ext.mongo |
  io.vertx.ext.reactivestreams |
  io.vertx.ext.shell |
  io.vertx.ext.shell.command |
  io.vertx.ext.shell.term |
  io.vertx.ext.stomp |
  io.vertx.ext.unit.junit |
  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.spi |
  io.vertx.ext.web.common.template |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.graphql.dataloader |
  io.vertx.ext.web.handler.graphql.schema |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.openapi |
  io.vertx.ext.web.openapi.router |
  io.vertx.ext.web.sstore |
  io.vertx.grpc.client |
  io.vertx.grpc.common |
  io.vertx.grpc.server |
  io.vertx.grpc.stub |
  io.vertx.httpproxy |
  io.vertx.json.schema |
  io.vertx.json.schema.common |
  io.vertx.junit5 |
  io.vertx.kafka.admin |
  io.vertx.kafka.client.consumer |
  io.vertx.kafka.client.producer |
  io.vertx.mqtt |
  io.vertx.mssqlclient |
  io.vertx.mysqlclient |
  io.vertx.openapi.contract |
  io.vertx.openapi.validation |
  io.vertx.pgclient |
  io.vertx.pgclient.pubsub |
  io.vertx.rabbitmq |
  io.vertx.reactivex |
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.core |
  io.vertx.reactivex.core.http |
  io.vertx.reactivex.db2client |
  io.vertx.reactivex.ext.auth.otp.hotp |
  io.vertx.reactivex.ext.auth.otp.totp |
  io.vertx.reactivex.ext.auth.webauthn |
  io.vertx.reactivex.ext.bridge |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.healthchecks |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.handler |
  io.vertx.reactivex.ext.web.handler.graphql |
  io.vertx.reactivex.ext.web.handler.graphql.ws |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.openapi |
  io.vertx.reactivex.grpc.client |
  io.vertx.reactivex.grpc.common |
  io.vertx.reactivex.grpc.server |
  io.vertx.reactivex.json.schema |
  io.vertx.reactivex.mssqlclient |
  io.vertx.reactivex.mysqlclient |
  io.vertx.reactivex.oracleclient |
  io.vertx.reactivex.pgclient |
  io.vertx.reactivex.sqlclient |
  io.vertx.redis.client |
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.db2client |
  io.vertx.rxjava.ext.auth.otp.hotp |
  io.vertx.rxjava.ext.auth.otp.totp |
  io.vertx.rxjava.ext.auth.webauthn |
  io.vertx.rxjava.ext.bridge |
  io.vertx.rxjava.ext.eventbus.bridge.tcp |
  io.vertx.rxjava.ext.healthchecks |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.graphql |
  io.vertx.rxjava.ext.web.handler.graphql.ws |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.grpc.client |
  io.vertx.rxjava.grpc.common |
  io.vertx.rxjava.grpc.server |
  io.vertx.rxjava.json.schema |
  io.vertx.rxjava.mssqlclient |
  io.vertx.rxjava.mysqlclient |
  io.vertx.rxjava.oracleclient |
  io.vertx.rxjava.pgclient |
  io.vertx.rxjava.sqlclient |
  io.vertx.rxjava3 |
  io.vertx.rxjava3.amqp |
  io.vertx.rxjava3.core |
  io.vertx.rxjava3.ext.auth.otp.hotp |
  io.vertx.rxjava3.ext.auth.otp.totp |
  io.vertx.rxjava3.ext.bridge |
  io.vertx.rxjava3.ext.eventbus.bridge.tcp |
  io.vertx.rxjava3.ext.web.handler.graphql |
  io.vertx.rxjava3.ext.web.handler.graphql.ws |
  io.vertx.rxjava3.ext.web.handler.sockjs |
  io.vertx.rxjava3.ext.web.openapi |
  io.vertx.rxjava3.json.schema |
  io.vertx.rxjava3.sqlclient |
  io.vertx.servicediscovery |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.types |
  io.vertx.serviceproxy |
  io.vertx.sqlclient |
  io.vertx.sqlclient.spi |
  io.vertx.sqlclient.templates |

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

    Methods in io.vertx.amqp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | AmqpConnection.`close()` Like `AmqpConnection.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AmqpSender.`close()` Like `AmqpSender.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AmqpReceiver.`close()` Like `AmqpReceiver.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AmqpClient.`close()` Like `AmqpClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AmqpConnection.`closeFuture()`
    `Future<AmqpConnection>` | AmqpClient.`connect()` Like `AmqpClient.connect(Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpSender>` | AmqpConnection.`createAnonymousSender()` Like `AmqpConnection.createAnonymousSender(Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpReceiver>` | AmqpConnection.`createDynamicReceiver()` Like `AmqpConnection.createDynamicReceiver(Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver(String address)` Like `AmqpConnection.createReceiver(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver(String address)` Like `AmqpClient.createReceiver(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions)` Like `AmqpConnection.createReceiver(String, AmqpReceiverOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions)` Like `AmqpClient.createReceiver(String, AmqpReceiverOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpSender>` | AmqpConnection.`createSender(String address)` Like `AmqpConnection.createSender(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpSender>` | AmqpClient.`createSender(String address)` Like `AmqpClient.createSender(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpSender>` | AmqpConnection.`createSender(String address, AmqpSenderOptions options)` Like `AmqpConnection.createSender(String, AmqpSenderOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<AmqpSender>` | AmqpClient.`createSender(String address, AmqpSenderOptions options)` Like `AmqpClient.createSender(String, AmqpSenderOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AmqpSender.`sendWithAck(AmqpMessage message)` Like `AmqpSender.sendWithAck(AmqpMessage, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.cassandra that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | ResultSet.`all()` Like `ResultSet.all(Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | CassandraClient.`close()` Like `CassandraClient.close(Handler)` but returns a `Future` of the asynchronous result.
    `Future<ResultSet>` | CassandraClient.`execute(com.datastax.oss.driver.api.core.cql.Statement statement)` Like `CassandraClient.execute(Statement, Handler)` but returns a `Future` of the asynchronous result.
    `<R> Future<R>` | 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)` Like `CassandraClient.execute(Statement, Collector, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ResultSet>` | CassandraClient.`execute(String query)` Like `CassandraClient.execute(String, Handler)` but returns a `Future` of the asynchronous result.
    `<R> Future<R>` | CassandraClient.`execute(String query, java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,?,R> collector)` Like `CassandraClient.execute(String, Collector, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement)` Like `CassandraClient.executeWithFullFetch(Statement, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch(String query)` Like `CassandraClient.executeWithFullFetch(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ResultSet>` | ResultSet.`fetchNextPage()`
    `Future<com.datastax.oss.driver.api.core.metadata.Metadata>` | CassandraClient.`metadata()` Like `CassandraClient.metadata(Handler)` but returns a `Future` of the asynchronous result.
    `default Future<Void>` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst)`
    `Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>` | CassandraClient.`prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement)` Like `CassandraClient.prepare(SimpleStatement, Handler)` but returns a `Future` of the asynchronous result.
    `Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>` | CassandraClient.`prepare(String query)` Like `CassandraClient.prepare(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream(com.datastax.oss.driver.api.core.cql.Statement statement)` Like `CassandraClient.queryStream(Statement, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream(String sql)` Like `CassandraClient.queryStream(String, Handler)` but returns a `Future` of the asynchronous result.

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

    Methods in io.vertx.circuitbreaker that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.

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

    Methods in io.vertx.config that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<JsonObject>` | ConfigRetriever.`getConfig()` Like `ConfigRetriever.getConfig(Handler)` but returns a `Future` of the asynchronous result

  - ### Uses of Future in io.vertx.config.consul

    Methods in io.vertx.config.consul that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | ConsulConfigStore.`close()`
    `Future<Buffer>` | ConsulConfigStore.`get()`

  - ### Uses of Future in io.vertx.config.git

    Methods in io.vertx.config.git that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | GitConfigStore.`close()`
    `Future<Buffer>` | GitConfigStore.`get()`

  - ### Uses of Future in io.vertx.config.hocon

    Methods in io.vertx.config.hocon that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<JsonObject>` | HoconProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input)`

  - ### Uses of Future in io.vertx.config.kubernetes

    Methods in io.vertx.config.kubernetes that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | ConfigMapStore.`close()`
    `Future<Buffer>` | ConfigMapStore.`get()`

  - ### Uses of Future in io.vertx.config.redis

    Methods in io.vertx.config.redis that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | RedisConfigStore.`close()`
    `Future<Buffer>` | RedisConfigStore.`get()`

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

    Methods in io.vertx.config.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | ConfigStore.`close()` Closes the configuration store.
    `default Future<Buffer>` | ConfigStore.`get()` Retrieves the configuration store in this store.
    `default Future<JsonObject>` | ConfigProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input)` Transforms the given `input` into a `JsonObject`.

  - ### Uses of Future in io.vertx.config.vault

    Methods in io.vertx.config.vault that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | VaultConfigStore.`close()`
    `Future<Buffer>` | VaultConfigStore.`get()`

  - ### Uses of Future in io.vertx.config.yaml

    Methods in io.vertx.config.yaml that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<JsonObject>` | YamlProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input)`

  - ### Uses of Future in io.vertx.config.zookeeper

    Methods in io.vertx.config.zookeeper that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | ZookeeperConfigStore.`close()`
    `Future<Buffer>` | ZookeeperConfigStore.`get()`

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

    Subinterfaces of Future 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.

    Methods in io.vertx.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<T>` | Future.`andThen(Handler<AsyncResult<T>> handler)` Invokes the given `handler` upon completion.
    `Future<Void>` | Vertx.`close()` Stop the Vertx instance and release any resources held by it.
    `Future<Void>` | WorkerExecutor.`close()` Like `WorkerExecutor.close(Handler)` but returns a `Future` of the asynchronous result
    `static Future<Vertx>` | Vertx.`clusteredVertx(VertxOptions options)` Same as `Vertx.clusteredVertx(VertxOptions, Handler)` but with an `handler` called when the operation completes
    `default <U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> successMapper, java.util.function.Function<Throwable,Future<U>> failureMapper)` Compose this future with a `successMapper` and `failureMapper` functions.
    `Future<String>` | Vertx.`deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions)` but `Verticle` instance is created by invoking the default constructor of `verticleClass`.
    `default Future<String>` | Vertx.`deployVerticle(String name)` Deploy a verticle instance given a name.
    `Future<String>` | Vertx.`deployVerticle(String name, DeploymentOptions options)` Like `Vertx.deployVerticle(Verticle)` but `DeploymentOptions` are provided to configure the deployment.
    `Future<String>` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `default Future<String>` | Vertx.`deployVerticle(Verticle verticle)` Deploy a verticle instance that you have created yourself.
    `Future<String>` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options)` Like `Vertx.deployVerticle(Verticle)` but `DeploymentOptions` are provided to configure the deployment.
    `<U> Future<T>` | Future.`eventually(java.util.function.Function<Void,Future<U>> mapper)` Compose this future with a `mapper` that will be always be called.
    `default <T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Context.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
    `default <T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Vertx.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
    `default <T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `<T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `Context.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `default <T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `Vertx.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `<T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `static <T> Future<T>` | Future.`failedFuture(String failureMessage)` Create a failed future with the specified failure message.
    `static <T> Future<T>` | Future.`failedFuture(Throwable t)` Create a failed future with the specified failure cause.
    `default <U> Future<U>` | Future.`flatMap(java.util.function.Function<T,Future<U>> mapper)` Alias for `compose(Function)`.
    `static <T> Future<T>` | Future.`fromCompletionStage(CompletionStage<T> completionStage)` Bridges a `CompletionStage` object to a Vert.x future instance.
    `static <T> Future<T>` | Future.`fromCompletionStage(CompletionStage<T> completionStage, Context context)` Bridges a `CompletionStage` object to a Vert.x future instance.
    `Future<T>` | Promise.`future()`
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `<U> Future<U>` | Future.`map(java.util.function.Function<T,U> mapper)` Apply a `mapper` function on this future.
    `<V> Future<V>` | Future.`map(V value)` Map the result of a future to a specific `value`.
    `default <V> Future<V>` | Future.`mapEmpty()` Map the result of a future to `null`.
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `default Future<T>` | Future.`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
    `default Future<T>` | Future.`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
    `Future<T>` | Future.`otherwise(java.util.function.Function<Throwable,T> mapper)` Apply a `mapper` function on this future.
    `Future<T>` | Future.`otherwise(T value)` Map the failure of a future to a specific `value`.
    `default Future<T>` | Future.`otherwiseEmpty()` Map the failure of a future to `null`.
    `default Future<T>` | Future.`recover(java.util.function.Function<Throwable,Future<T>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `static <T> Future<T>` | Future.`succeededFuture()` Create a succeeded future with a null result
    `static <T> Future<T>` | Future.`succeededFuture(T result)` Created a succeeded future with the specified result.
    `<U> Future<U>` | Future.`transform(java.util.function.Function<AsyncResult<T>,Future<U>> mapper)` Transform this future with a `mapper` functions.
    `Future<Void>` | Vertx.`undeploy(String deploymentID)` Undeploy a verticle deployment.

    Methods in io.vertx.core with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T1,T2> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(Future, Future)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(Future, Future)` but with 6 futures.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(Future, Future)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(Future, Future)` but with 6 futures.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(Future, Future)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(Future, Future)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(Future, Future)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(Future, Future)` but with 6 futures.

    Method parameters in io.vertx.core with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static CompositeFuture` | CompositeFuture.`all(List<Future> futures)` Like `CompositeFuture.all(Future, Future)` but with a list of futures.
    `static CompositeFuture` | CompositeFuture.`any(List<Future> futures)` Like `CompositeFuture.any(Future, Future)` but with a list of futures.
    `default <U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> successMapper, java.util.function.Function<Throwable,Future<U>> failureMapper)` Compose this future with a `successMapper` and `failureMapper` functions.
    `<U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> successMapper, java.util.function.Function<Throwable,Future<U>> failureMapper)` Compose this future with a `successMapper` and `failureMapper` functions.
    `<U> Future<T>` | Future.`eventually(java.util.function.Function<Void,Future<U>> mapper)` Compose this future with a `mapper` that will be always be called.
    `default <U> Future<U>` | Future.`flatMap(java.util.function.Function<T,Future<U>> mapper)` Alias for `compose(Function)`.
    `static CompositeFuture` | CompositeFuture.`join(List<Future> futures)` Like `CompositeFuture.join(Future, Future)` but with a list of futures.
    `default Future<T>` | Future.`recover(java.util.function.Function<Throwable,Future<T>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `<U> Future<U>` | Future.`transform(java.util.function.Function<AsyncResult<T>,Future<U>> mapper)` Transform this future with a `mapper` functions.

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

    Methods in io.vertx.core.datagram that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock)` Like `DatagramSocket.blockMulticastGroup(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock)` Like `DatagramSocket.blockMulticastGroup(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`close()` Closes the `DatagramSocket`.
    `Future<DatagramSocket>` | DatagramSocket.`listen(int port, String host)` Like `DatagramSocket.listen(int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`listenMulticastGroup(String multicastAddress)` Like `DatagramSocket.listenMulticastGroup(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source)` Like `DatagramSocket.listenMulticastGroup(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`send(Buffer packet, int port, String host)` Like `DatagramSocket.send(Buffer, int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`send(String str, int port, String host)` Like `DatagramSocket.send(String, int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`send(String str, String enc, int port, String host)` Like `DatagramSocket.send(String, String, int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress)` Like `DatagramSocket.unlistenMulticastGroup(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source)` Like `DatagramSocket.unlistenMulticastGroup(String, String, String, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.core.dns that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<String>` | DnsClient.`lookup(String name)` Like `DnsClient.lookup(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | DnsClient.`lookup4(String name)` Like `DnsClient.lookup4(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | DnsClient.`lookup6(String name)` Like `DnsClient.lookup6(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | DnsClient.`resolveA(String name)` Like `DnsClient.resolveA(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | DnsClient.`resolveAAAA(String name)` Like `DnsClient.resolveAAAA(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | DnsClient.`resolveCNAME(String name)` Like `DnsClient.resolveCNAME(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<MxRecord>>` | DnsClient.`resolveMX(String name)` Like `DnsClient.resolveMX(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | DnsClient.`resolveNS(String name)` Like `DnsClient.resolveNS(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | DnsClient.`resolvePTR(String name)` Like `DnsClient.resolvePTR(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<SrvRecord>>` | DnsClient.`resolveSRV(String name)` Like `DnsClient.resolveSRV(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | DnsClient.`resolveTXT(String name)` Like `DnsClient.resolveTXT(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | DnsClient.`reverseLookup(String ipaddress)` Like `DnsClient.reverseLookup(String, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.core.eventbus that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | MessageProducer.`close()` Closes the producer, this method should be called when the message producer is not used anymore.
    `default <R> Future<Message<R>>` | Message.`replyAndRequest(Object message)` Like `Message.replyAndRequest(Object, Handler)` but returns a `Future` of the asynchronous result
    `<R> Future<Message<R>>` | Message.`replyAndRequest(Object message, DeliveryOptions options)` Like `Message.replyAndRequest(Object, DeliveryOptions, Handler)` but returns a `Future` of the asynchronous result
    `default <T> Future<Message<T>>` | EventBus.`request(String address, Object message)` Like `EventBus.request(String, Object, Handler)` but returns a `Future` of the asynchronous result
    `<T> Future<Message<T>>` | EventBus.`request(String address, Object message, DeliveryOptions options)` Like `EventBus.request(String, Object, DeliveryOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MessageConsumer.`unregister()` Unregisters the handler which created this registration
    `Future<Void>` | MessageProducer.`write(T body)` Like `MessageProducer.write(Object, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.core.file that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | FileSystem.`chmod(String path, String perms)` Like `FileSystem.chmod(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms)` Like `FileSystem.chmodRecursive(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`chown(String path, String user, String group)` Like `FileSystem.chown(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncFile.`close()` Close the file.
    `Future<Void>` | FileSystem.`copy(String from, String to)` Like `FileSystem.copy(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`copy(String from, String to, CopyOptions options)` Like `FileSystem.copy(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`copyRecursive(String from, String to, boolean recursive)` Like `FileSystem.copyRecursive(String, String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`createFile(String path)` Like `FileSystem.createFile(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`createFile(String path, String perms)` Like `FileSystem.createFile(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempDirectory(String prefix)` Like `FileSystem.createTempDirectory(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempDirectory(String prefix, String perms)` Like `FileSystem.createTempDirectory(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempDirectory(String dir, String prefix, String perms)` Like `FileSystem.createTempDirectory(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempFile(String prefix, String suffix)` Like `FileSystem.createTempFile(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempFile(String prefix, String suffix, String perms)` Like `FileSystem.createTempFile(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms)` Like `FileSystem.createTempFile(String, String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`delete(String path)` Like `FileSystem.delete(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`deleteRecursive(String path, boolean recursive)` Like `FileSystem.deleteRecursive(String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Boolean>` | FileSystem.`exists(String path)` Like `FileSystem.exists(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncFile.`flush()` Flush any writes made to this file to underlying persistent storage.
    `Future<FileSystemProps>` | FileSystem.`fsProps(String path)` Like `FileSystem.fsProps(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Boolean>` | AsyncFileLock.`isValid()` A lock remains valid until it is released or the file corresponding `AsyncFile` is closed.
    `Future<Void>` | FileSystem.`link(String link, String existing)` Like `FileSystem.link(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<AsyncFileLock>` | AsyncFile.`lock()` Acquire a non-shared lock on the entire file.
    `Future<AsyncFileLock>` | AsyncFile.`lock(long position, long size, boolean shared)` Acquire a lock on a portion of this file.
    `Future<FileProps>` | FileSystem.`lprops(String path)` Like `FileSystem.lprops(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`mkdir(String path)` Like `FileSystem.mkdir(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`mkdir(String path, String perms)` Like `FileSystem.mkdir(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`mkdirs(String path)` Like `FileSystem.mkdirs(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`mkdirs(String path, String perms)` Like `FileSystem.mkdirs(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`move(String from, String to)` Like `FileSystem.move(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`move(String from, String to, CopyOptions options)` Like `FileSystem.move(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<AsyncFile>` | FileSystem.`open(String path, OpenOptions options)` Like `FileSystem.open(String, OpenOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<FileProps>` | FileSystem.`props(String path)` Like `FileSystem.props(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Buffer>` | AsyncFile.`read(Buffer buffer, int offset, long position, int length)` Like `AsyncFile.read(Buffer, int, long, int, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | FileSystem.`readDir(String path)` Like `FileSystem.readDir(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | FileSystem.`readDir(String path, String filter)` Like `FileSystem.readDir(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Buffer>` | FileSystem.`readFile(String path)` Like `FileSystem.readFile(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | FileSystem.`readSymlink(String link)` Like `FileSystem.readSymlink(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncFileLock.`release()` Releases this lock;
    `Future<Long>` | AsyncFile.`size()`
    `Future<Void>` | FileSystem.`symlink(String link, String existing)` Like `FileSystem.symlink(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`truncate(String path, long len)` Like `FileSystem.truncate(String, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`unlink(String link)` Like `FileSystem.unlink(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncFile.`write(Buffer buffer, long position)` Like `AsyncFile.write(Buffer, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | FileSystem.`writeFile(String path, Buffer data)` Like `FileSystem.writeFile(String, Buffer, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.core.http that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Buffer>` | HttpClientResponse.`body()` Convenience method for receiving the entire request body in one piece.
    `Future<Buffer>` | HttpServerRequest.`body()` Convenience method for receiving the entire request body in one piece.
    `Future<Void>` | ServerWebSocket.`close()` Close the WebSocket sending the default close frame.
    `Future<Void>` | HttpServer.`close()` Close the server.
    `Future<Void>` | HttpConnection.`close()` Like `HttpConnection.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpClient.`close()` Like `HttpClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | WebSocketBase.`close()` Close the WebSocket sending the default close frame.
    `Future<Void>` | WebSocketBase.`close(short statusCode)` Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | WebSocketBase.`close(short statusCode, String reason)` Close sending a close frame with specified status code and reason.
    `Future<HttpClientResponse>` | HttpClientRequest.`connect()` Like `HttpClientRequest.connect(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpClientResponse.`end()` Returns a future signaling when the response has been fully received successfully or failed.
    `Future<Void>` | HttpServerResponse.`end()` Ends the response.
    `Future<Void>` | HttpClientRequest.`end()` Ends the request.
    `Future<Void>` | HttpServerRequest.`end()` Returns a future signaling when the request has been fully received successfully or failed.
    `Future<Void>` | WebSocketBase.`end()` Ends the stream.
    `Future<Void>` | HttpServerResponse.`end(Buffer chunk)` Same as `HttpServerResponse.end()` but writes some data to the response body before ending.
    `Future<Void>` | HttpClientRequest.`end(Buffer chunk)` Same as `HttpClientRequest.end()` but writes some data to the request body before ending.
    `Future<Void>` | HttpServerResponse.`end(String chunk)` Same as `HttpServerResponse.end(Buffer)` but writes a String in UTF-8 encoding before ending the response.
    `Future<Void>` | HttpClientRequest.`end(String chunk)` Same as `HttpClientRequest.end(Buffer)` but writes a String in UTF-8 encoding
    `Future<Void>` | HttpServerResponse.`end(String chunk, String enc)` Same as `HttpServerResponse.end(Buffer)` but writes a String with the specified encoding before ending the response.
    `Future<Void>` | HttpClientRequest.`end(String chunk, String enc)` Same as `HttpClientRequest.end(Buffer)` but writes a String with the specified encoding
    `Future<HttpServer>` | HttpServer.`listen()` Tell the server to start listening.
    `default Future<HttpServer>` | HttpServer.`listen(int port)` Like `HttpServer.listen(int, String)` but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the `HttpServerOptions` that was used when creating the server.
    `default Future<HttpServer>` | HttpServer.`listen(int port, String host)` Tell the server to start listening.
    `Future<HttpServer>` | HttpServer.`listen(SocketAddress address)` Like `HttpServer.listen(SocketAddress, Handler)` but returns a `Future` of the asynchronous result
    `Future<Buffer>` | HttpConnection.`ping(Buffer data)` Same as `HttpConnection.ping(Buffer, Handler)` but returns a `Future` of the asynchronous result
    `default Future<HttpServerResponse>` | HttpServerResponse.`push(HttpMethod method, String path)` Same as `HttpServerResponse.push(HttpMethod, String, Handler)` but with an `handler` called when the operation completes
    `default Future<HttpServerResponse>` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers)` Same as `HttpServerResponse.push(HttpMethod, String, MultiMap, Handler)` but with an `handler` called when the operation completes
    `default Future<HttpServerResponse>` | HttpServerResponse.`push(HttpMethod method, String host, String path)` Same as `HttpServerResponse.push(HttpMethod, String, String, Handler)` but with an `handler` called when the operation completes
    `Future<HttpServerResponse>` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers)` Same as `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` but with an `handler` called when the operation completes
    `Future<HttpClientRequest>` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI)` Like `HttpClient.request(HttpMethod, int, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<HttpClientRequest>` | HttpClient.`request(HttpMethod method, String requestURI)` Like `HttpClient.request(HttpMethod, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<HttpClientRequest>` | HttpClient.`request(HttpMethod method, String host, String requestURI)` Like `HttpClient.request(HttpMethod, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<HttpClientRequest>` | HttpClient.`request(RequestOptions options)` Like `HttpClient.request(RequestOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<HttpClientResponse>` | HttpClientRequest.`response()`
    `default Future<Void>` | HttpServerResponse.`send()` Like `HttpServerResponse.send(Handler)` but returns a `Future` of the asynchronous result
    `default Future<HttpClientResponse>` | HttpClientRequest.`send()` Like `HttpClientRequest.send(Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | HttpServerResponse.`send(Buffer body)` Like `HttpServerResponse.send(Buffer, Handler)` but returns a `Future` of the asynchronous result
    `default Future<HttpClientResponse>` | HttpClientRequest.`send(Buffer body)` Like `HttpClientRequest.send(Buffer, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | HttpServerResponse.`send(ReadStream<Buffer> body)` Like `HttpServerResponse.send(ReadStream, Handler)` but returns a `Future` of the asynchronous result
    `default Future<HttpClientResponse>` | HttpClientRequest.`send(ReadStream<Buffer> body)` Like `HttpClientRequest.send(ReadStream, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | HttpServerResponse.`send(String body)` Like `HttpServerResponse.send(String, Handler)` but returns a `Future` of the asynchronous result
    `default Future<HttpClientResponse>` | HttpClientRequest.`send(String body)` Like `HttpClientRequest.send(String, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | HttpServerResponse.`sendFile(String filename)` Same as `HttpServerResponse.sendFile(String, long)` using offset @code{0} which means starting from the beginning of the file.
    `default Future<Void>` | HttpServerResponse.`sendFile(String filename, long offset)` Same as `HttpServerResponse.sendFile(String, long, long)` using length @code{Long.MAX_VALUE} which means until the end of the file.
    `Future<Void>` | HttpServerResponse.`sendFile(String filename, long offset, long length)` Ask the OS to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | HttpClientRequest.`sendHead()` Forces the head of the request to be written before `HttpClientRequest.end()` is called on the request or any data is written to it.
    `Future<Integer>` | ServerWebSocket.`setHandshake(Future<Integer> future)` Like `ServerWebSocket.setHandshake(Future, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | HttpConnection.`shutdown()` Like `HttpConnection.shutdown(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpConnection.`shutdown(long timeoutMs)` Like `HttpConnection.shutdown(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpServerFileUpload.`streamToFileSystem(String filename)` Stream the content of this upload to the given file on storage.
    `Future<NetSocket>` | HttpServerRequest.`toNetSocket()` Like `HttpServerRequest.toNetSocket(Handler)` but returns a `Future` of the asynchronous result
    `Future<ServerWebSocket>` | HttpServerRequest.`toWebSocket()` Like `HttpServerRequest.toWebSocket(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpConnection.`updateSettings(Http2Settings settings)` Send to the remote endpoint an update of the server settings.
    `Future<Void>` | HttpServer.`updateSSLOptions(SSLOptions options)` Update the server SSL options.
    `Future<Void>` | HttpClient.`updateSSLOptions(SSLOptions options)` Update the client SSL options.
    `Future<WebSocket>` | HttpClient.`webSocket(int port, String host, String requestURI)` Like `HttpClient.webSocket(int, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<WebSocket>` | HttpClient.`webSocket(String requestURI)` Like `HttpClient.webSocket(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<WebSocket>` | HttpClient.`webSocket(String host, String requestURI)` Like `HttpClient.webSocket(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<WebSocket>` | HttpClient.`webSocket(WebSocketConnectOptions options)` Like `HttpClient.webSocket(WebSocketConnectOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<WebSocket>` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols)` Like `HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | HttpServerResponse.`write(String chunk)` Write a `String` to the response body, encoded in UTF-8.
    `Future<Void>` | HttpClientRequest.`write(String chunk)` Write a `String` to the request body, encoded as UTF-8.
    `Future<Void>` | HttpServerResponse.`write(String chunk, String enc)` Write a `String` to the response body, encoded using the encoding `enc`.
    `Future<Void>` | HttpClientRequest.`write(String chunk, String enc)` Write a `String` to the request body, encoded using the encoding `enc`.
    `Future<Void>` | WebSocketBase.`writeBinaryMessage(Buffer data)` Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | HttpServerResponse.`writeEarlyHints(MultiMap headers)` Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
    `Future<Void>` | WebSocketBase.`writeFinalBinaryFrame(Buffer data)` Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalTextFrame(String text)` Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocketBase.`writeFrame(WebSocketFrame frame)` Write a WebSocket frame to the connection
    `Future<Void>` | WebSocketBase.`writePing(Buffer data)` Like `WebSocketBase.writePing(Buffer, Handler)` but with an `handler` called when the message has been written or failed to be written.
    `Future<Void>` | WebSocketBase.`writePong(Buffer data)` Like `WebSocketBase.writePong(Buffer, Handler)` but with an `handler` called when the message has been written or failed to be written.
    `Future<Void>` | WebSocketBase.`writeTextMessage(String text)` Writes a (potentially large) piece of text data to the connection.

    Methods in io.vertx.core.http that return types with arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `java.util.function.Function<HttpClientResponse,Future<RequestOptions>>` | HttpClient.`redirectHandler()`

    Methods in io.vertx.core.http with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Integer>` | ServerWebSocket.`setHandshake(Future<Integer> future)` Like `ServerWebSocket.setHandshake(Future, Handler)` but returns a `Future` of the asynchronous result
    `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.

    Method parameters in io.vertx.core.http with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpClient` | HttpClient.`redirectHandler(java.util.function.Function<HttpClientResponse,Future<RequestOptions>> handler)` Set a redirect handler for the http client.

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

    Methods in io.vertx.core.net that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | NetClient.`close()` Like `NetClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | NetSocket.`close()` Close the NetSocket
    `Future<Void>` | NetServer.`close()` Close the server.
    `Future<NetSocket>` | NetClient.`connect(int port, String host)` Like `NetClient.connect(int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<NetSocket>` | NetClient.`connect(int port, String host, String serverName)` Like `NetClient.connect(int, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<NetSocket>` | NetClient.`connect(SocketAddress remoteAddress)` Like `NetClient.connect(SocketAddress, Handler)` but returns a `Future` of the asynchronous result
    `Future<NetSocket>` | NetClient.`connect(SocketAddress remoteAddress, String serverName)` Like `NetClient.connect(SocketAddress, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | NetSocket.`end()` Calls `NetSocket.close()`
    `Future<NetServer>` | NetServer.`listen()` Start listening on the port and host as configured in the `NetServerOptions` used when creating the server.
    `default Future<NetServer>` | NetServer.`listen(int port)` Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default Future<NetServer>` | NetServer.`listen(int port, String host)` Start listening on the specified port and host, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `Future<NetServer>` | NetServer.`listen(SocketAddress localAddress)` Start listening on the specified local address, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default Future<Void>` | NetSocket.`sendFile(String filename)` Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `default Future<Void>` | NetSocket.`sendFile(String filename, long offset)` Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetSocket.`sendFile(String filename, long offset, long length)` Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetClient.`updateSSLOptions(SSLOptions options)` Update the client SSL options.
    `Future<Void>` | NetServer.`updateSSLOptions(SSLOptions options)` Update the server SSL options.
    `Future<Void>` | NetSocket.`upgradeToSsl()` Like `NetSocket.upgradeToSsl(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | NetSocket.`upgradeToSsl(String serverName)` Like `NetSocket.upgradeToSsl(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | NetSocket.`write(String str)` Write a `String` to the connection, encoded in UTF-8.
    `Future<Void>` | NetSocket.`write(String str, String enc)` Write a `String` to the connection, encoded using the encoding `enc`.

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

    Methods in io.vertx.core.shareddata that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Long>` | Counter.`addAndGet(long value)` Same as `Counter.addAndGet(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncMap.`clear()` Same as `AsyncMap.clear(Handler)` but returns a `Future` of the asynchronous result
    `Future<Boolean>` | Counter.`compareAndSet(long expected, long value)` Same as `Counter.compareAndSet(long, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | Counter.`decrementAndGet()` Same as `Counter.decrementAndGet(Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<K,V>>` | AsyncMap.`entries()` Same as `AsyncMap.entries(Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | Counter.`get()` Same as `Counter.get(Handler)` but returns a `Future` of the asynchronous result
    `Future<V>` | AsyncMap.`get(K k)` Same as `#get(K, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | Counter.`getAndAdd(long value)` Same as `Counter.getAndAdd(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | Counter.`getAndIncrement()` Same as `Counter.getAndIncrement(Handler)` but returns a `Future` of the asynchronous result
    `<K,V> Future<AsyncMap<K,V>>` | SharedData.`getAsyncMap(String name)` Same as `SharedData.getAsyncMap(String, Handler)` but returns a `Future` of the asynchronous result
    `<K,V> Future<AsyncMap<K,V>>` | SharedData.`getClusterWideMap(String name)` Same as `SharedData.getClusterWideMap(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Counter>` | SharedData.`getCounter(String name)` Same as `SharedData.getCounter(String, Handler)` but returns a `Future` of the asynchronous result
    `<K,V> Future<AsyncMap<K,V>>` | SharedData.`getLocalAsyncMap(String name)` Same as `SharedData.getLocalAsyncMap(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Counter>` | SharedData.`getLocalCounter(String name)` Same as `SharedData.getLocalCounter(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Lock>` | SharedData.`getLocalLock(String name)` Same as `SharedData.getLocalLock(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Lock>` | SharedData.`getLocalLockWithTimeout(String name, long timeout)` Same as `SharedData.getLocalLockWithTimeout(String, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Lock>` | SharedData.`getLock(String name)` Same as `SharedData.getLock(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Lock>` | SharedData.`getLockWithTimeout(String name, long timeout)` Same as `SharedData.getLockWithTimeout(String, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | Counter.`incrementAndGet()` Same as `Counter.incrementAndGet(Handler)` but returns a `Future` of the asynchronous result
    `Future<Set<K>>` | AsyncMap.`keys()` Same as `AsyncMap.keys(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncMap.`put(K k, V v)` Same as `#put(K, V, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | AsyncMap.`put(K k, V v, long ttl)` Same as `#put(K, V, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<V>` | AsyncMap.`putIfAbsent(K k, V v)` Same as `#putIfAbsent(K, V, Handler)` but returns a `Future` of the asynchronous result
    `Future<V>` | AsyncMap.`putIfAbsent(K k, V v, long ttl)` Same as `#putIfAbsent(K, V, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<V>` | AsyncMap.`remove(K k)` Same as `#remove(K, Handler)` but returns a `Future` of the asynchronous result
    `Future<Boolean>` | AsyncMap.`removeIfPresent(K k, V v)` Same as `#removeIfPresent(K, V, Handler)` but returns a `Future` of the asynchronous result
    `Future<V>` | AsyncMap.`replace(K k, V v)` Same as `#replace(K, V, Handler)` but returns a `Future` of the asynchronous result
    `default Future<V>` | AsyncMap.`replace(K k, V v, long ttl)` Same as `#replace(K, V, long, Handler)` but returns a `Future` of the asynchronous result returns UnsupportedOperationException if the implementation does not support it
    `Future<Boolean>` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue)` Same as `#replaceIfPresent(K, V, V, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Boolean>` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, long ttl)` Same as `#replaceIfPresent(K, V, V, long, Handler)` but returns a `Future` of the asynchronous result returns UnsupportedOperationException if the implementation does not support it
    `Future<Integer>` | AsyncMap.`size()` Same as `AsyncMap.size(Handler)` but returns a `Future` of the asynchronous result
    `Future<List<V>>` | AsyncMap.`values()` Same as `AsyncMap.values(Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.core.streams that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | WriteStream.`end()` Ends the stream.
    `default Future<Void>` | WriteStream.`end(T data)` Same as `WriteStream.end()` but writes some data to the stream before ending.
    `default Future<Void>` | ReadStream.`pipeTo(WriteStream<T> dst)` Same as `ReadStream.pipeTo(WriteStream, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | Pipe.`to(WriteStream<T> dst)` Same as `Pipe.to(WriteStream, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | WriteStream.`write(T data)` Write some data to the stream.

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

    Methods in io.vertx.db2client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<DB2Connection>` | DB2Connection.`connect(Vertx vertx, DB2ConnectOptions connectOptions)` Like `DB2Connection.connect(Vertx, DB2ConnectOptions, Handler)` but returns a `Future` of the asynchronous result
    `static Future<DB2Connection>` | DB2Connection.`connect(Vertx vertx, String connectionUri)` Like `DB2Connection.connect(Vertx, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DB2Connection.`debug()` Like `DB2Connection.debug(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | DB2Connection.`ping()` Like `DB2Connection.ping(Handler)` but returns a `Future` of the asynchronous result

    Method parameters in io.vertx.db2client with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `DB2Pool` | DB2Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Methods in io.vertx.ext.auth that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Boolean>` | User.`isAuthorized(Authorization authority)` Deprecated.
    `default Future<Boolean>` | User.`isAuthorized(String authority)` Deprecated. Use typed alternative `User.isAuthorized(Authorization)`

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

    Methods in io.vertx.ext.auth.authentication that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<User>` | AuthenticationProvider.`authenticate(Credentials credentials)` Authenticate a user.
    `default Future<User>` | AuthenticationProvider.`authenticate(JsonObject credentials)` Deprecated. For type safety this method should be avoided and `AuthenticationProvider.authenticate(Credentials)` should be used instead.

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

    Methods in io.vertx.ext.auth.authorization that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | AuthorizationProvider.`getAuthorizations(User user)` Updates the user with the set of authorizations.

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

    Methods in io.vertx.ext.auth.jdbc that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | JDBCUserUtil.`createHashedUser(String username, String hash)` Deprecated.
    `default Future<Void>` | JDBCUserUtil.`createRolePermission(String role, String permission)` Deprecated.
    `default Future<Void>` | JDBCUserUtil.`createUser(String username, String password)` Deprecated.
    `default Future<Void>` | JDBCUserUtil.`createUserRole(String user, String role)` Deprecated.

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

    Methods in io.vertx.ext.auth.mongo that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<String>` | MongoUserUtil.`createHashedUser(String username, String hash)`
    `Future<String>` | MongoUserUtil.`createUser(String username, String password)`
    `Future<String>` | MongoUserUtil.`createUserRolesAndPermissions(String user, List<String> roles, List<String> permissions)`
    `Future<String>` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions)` Deprecated. Please use `MongoUserUtil` instead. Insert a new user into mongo in the convenient way

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

    Methods in io.vertx.ext.auth.oauth2 that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | OAuth2Auth.`jWKSet()` Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
    `Future<User>` | OAuth2Auth.`refresh(User user)` Refresh the current User (access token).
    `default Future<Void>` | OAuth2Auth.`revoke(User user)` Revoke an obtained access token.
    `Future<Void>` | OAuth2Auth.`revoke(User user, String tokenType)` Revoke an obtained access or refresh token.
    `Future<JsonObject>` | OAuth2Auth.`userInfo(User user)` Retrieve profile information and other attributes for a logged-in end-user.

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

    Methods in io.vertx.ext.auth.oauth2.providers that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<OAuth2Auth>` | SalesforceAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | IBMCloudAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | GoogleAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | AzureADAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | KeycloakAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | AmazonCognitoAuth.`discover(Vertx vertx, OAuth2Options config)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Future in io.vertx.ext.auth.otp.hotp

    Methods in io.vertx.ext.auth.otp.hotp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | HotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.ext.auth.otp.hotp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HotpAuth` | HotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a `Function` that can fetch `Authenticator`s from a backend given an `identifier` argument.
    `HotpAuth` | HotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a `Function` that can update or insert a `Authenticator`.

  - ### Uses of Future in io.vertx.ext.auth.otp.totp

    Methods in io.vertx.ext.auth.otp.totp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | TotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.ext.auth.otp.totp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `TotpAuth` | TotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a `Function` that can fetch `Authenticator`s from a backend given an `identifier` argument.
    `TotpAuth` | TotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a `Function` that can update or insert a `Authenticator`.

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

    Methods in io.vertx.ext.auth.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | SqlUserUtil.`createHashedUser(String username, String hash)`
    `Future<Void>` | SqlUserUtil.`createRolePermission(String role, String permission)`
    `Future<Void>` | SqlUserUtil.`createUser(String username, String password)`
    `Future<Void>` | SqlUserUtil.`createUserRole(String user, String role)`

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

    Methods in io.vertx.ext.auth.webauthn that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<JsonObject>` | WebAuthn.`createCredentialsOptions(JsonObject user)` Same as `WebAuthn.createCredentialsOptions(JsonObject, Handler)` but returning a Future.
    `default Future<Boolean>` | MetaDataService.`fetchTOC()` Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
    `Future<Boolean>` | MetaDataService.`fetchTOC(String url)` Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
    `Future<JsonObject>` | WebAuthn.`getCredentialsOptions(String username)` Same as `WebAuthn.getCredentialsOptions(String, Handler)` but returning a Future.

    Method parameters in io.vertx.ext.auth.webauthn with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `WebAuthn` | WebAuthn.`authenticatorFetcher(java.util.function.Function<Authenticator,Future<List<Authenticator>>> fetcher)` Provide a `Function` that can fetch `Authenticator`s from a backend given the incomplete `Authenticator` argument.
    `WebAuthn` | WebAuthn.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a `Function` that can update or insert a `Authenticator`.

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

    Methods in io.vertx.ext.consul that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<JsonObject>` | ConsulClient.`agentInfo()` Like `ConsulClient.agentInfo(Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<String>>` | ConsulClient.`catalogDatacenters()` Like `ConsulClient.catalogDatacenters(Handler)` but returns a `Future` of the asynchronous result.
    `Future<NodeList>` | ConsulClient.`catalogNodes()` Like `ConsulClient.catalogNodes(Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogNodeServices(String node)` Like `ConsulClient.catalogNodeServices(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options)` Like `ConsulClient.catalogNodeServicesWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<NodeList>` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options)` Like `ConsulClient.catalogNodesWithOptions(NodeQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogServiceNodes(String service)` Like `ConsulClient.catalogServiceNodes(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options)` Like `ConsulClient.catalogServiceNodesWithOptions(String, ServiceQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogServices()` Like `ConsulClient.catalogServices(Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceList>` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options)` Like `ConsulClient.catalogServicesWithOptions(BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`cloneAclToken(String id)` Like `ConsulClient.cloneAclToken(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<DcCoordinates>>` | ConsulClient.`coordinateDatacenters()` Like `ConsulClient.coordinateDatacenters(Handler)` but returns a `Future` of the asynchronous result.
    `Future<CoordinateList>` | ConsulClient.`coordinateNodes()` Like `ConsulClient.coordinateNodes(Handler)` but returns a `Future` of the asynchronous result.
    `Future<CoordinateList>` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options)` Like `ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`createAclToken(AclToken token)` Like `ConsulClient.createAclToken(AclToken, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition)` Like `ConsulClient.createPreparedQuery(PreparedQueryDefinition, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`createSession()` Like `ConsulClient.createSession(Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`createSessionWithOptions(SessionOptions options)` Like `ConsulClient.createSessionWithOptions(SessionOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`deletePreparedQuery(String id)` Like `ConsulClient.deletePreparedQuery(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`deleteValue(String key)` Like `ConsulClient.deleteValue(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`deleteValues(String keyPrefix)` Like `ConsulClient.deleteValues(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`deregisterCheck(String checkId)` Like `ConsulClient.deregisterCheck(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`deregisterService(String id)` Like `ConsulClient.deregisterService(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`destroyAclToken(String id)` Like `ConsulClient.destroyAclToken(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`destroySession(String id)` Like `ConsulClient.destroySession(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<PreparedQueryExecuteResponse>` | ConsulClient.`executePreparedQuery(String query)` Like `ConsulClient.executePreparedQuery(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<PreparedQueryExecuteResponse>` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options)` Like `ConsulClient.executePreparedQueryWithOptions(String, PreparedQueryExecuteOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`failCheck(String checkId)` Like `ConsulClient.failCheck(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`failCheckWithNote(String checkId, String note)` Like `ConsulClient.failCheckWithNote(String, String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Event>` | ConsulClient.`fireEvent(String name)` Like `ConsulClient.fireEvent(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Event>` | ConsulClient.`fireEventWithOptions(String name, EventOptions options)` Like `ConsulClient.fireEventWithOptions(String, EventOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<PreparedQueryDefinition>>` | ConsulClient.`getAllPreparedQueries()` Like `ConsulClient.getAllPreparedQueries(Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<String>>` | ConsulClient.`getKeys(String keyPrefix)` Like `ConsulClient.getKeys(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<String>>` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options)` Like `ConsulClient.getKeysWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<PreparedQueryDefinition>` | ConsulClient.`getPreparedQuery(String id)` Like `ConsulClient.getPreparedQuery(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<KeyValue>` | ConsulClient.`getValue(String key)` Like `ConsulClient.getValue(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<KeyValueList>` | ConsulClient.`getValues(String keyPrefix)` Like `ConsulClient.getValues(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<KeyValueList>` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options)` Like `ConsulClient.getValuesWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<KeyValue>` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options)` Like `ConsulClient.getValueWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CheckList>` | ConsulClient.`healthChecks(String service)` Like `ConsulClient.healthChecks(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CheckList>` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options)` Like `ConsulClient.healthChecksWithOptions(String, CheckQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceEntryList>` | ConsulClient.`healthServiceNodes(String service, boolean passing)` Like `ConsulClient.healthServiceNodes(String, boolean, Handler)` but returns a `Future` of the asynchronous result.
    `Future<ServiceEntryList>` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options)` Like `ConsulClient.healthServiceNodesWithOptions(String, boolean, ServiceQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CheckList>` | ConsulClient.`healthState(HealthState healthState)` Like `ConsulClient.healthState(HealthState, Handler)` but returns a `Future` of the asynchronous result.
    `Future<CheckList>` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options)` Like `ConsulClient.healthStateWithOptions(HealthState, CheckQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<AclToken>` | ConsulClient.`infoAclToken(String id)` Like `ConsulClient.infoAclToken(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Session>` | ConsulClient.`infoSession(String id)` Like `ConsulClient.infoSession(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Session>` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options)` Like `ConsulClient.infoSessionWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`leaderStatus()` Like `ConsulClient.leaderStatus(Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<AclToken>>` | ConsulClient.`listAclTokens()` Like `ConsulClient.listAclTokens(Handler)` but returns a `Future` of the asynchronous result.
    `Future<EventList>` | ConsulClient.`listEvents()` Like `ConsulClient.listEvents(Handler)` but returns a `Future` of the asynchronous result.
    `Future<EventList>` | ConsulClient.`listEventsWithOptions(EventListOptions options)` Like `ConsulClient.listEventsWithOptions(EventListOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<SessionList>` | ConsulClient.`listNodeSessions(String nodeId)` Like `ConsulClient.listNodeSessions(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<SessionList>` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options)` Like `ConsulClient.listNodeSessionsWithOptions(String, BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<SessionList>` | ConsulClient.`listSessions()` Like `ConsulClient.listSessions(Handler)` but returns a `Future` of the asynchronous result.
    `Future<SessionList>` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options)` Like `ConsulClient.listSessionsWithOptions(BlockingQueryOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<Check>>` | ConsulClient.`localChecks()` Like `ConsulClient.localChecks(Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<Service>>` | ConsulClient.`localServices()` Like `ConsulClient.localServices(Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions)` Like `ConsulClient.maintenanceService(MaintenanceOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`passCheck(String checkId)` Like `ConsulClient.passCheck(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`passCheckWithNote(String checkId, String note)` Like `ConsulClient.passCheckWithNote(String, String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<List<String>>` | ConsulClient.`peersStatus()` Like `ConsulClient.peersStatus(Handler)` but returns a `Future` of the asynchronous result.
    `Future<Boolean>` | ConsulClient.`putValue(String key, String value)` Like `ConsulClient.putValue(String, String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Boolean>` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options)` Like `ConsulClient.putValueWithOptions(String, String, KeyValueOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`registerCheck(CheckOptions checkOptions)` Like `ConsulClient.registerCheck(CheckOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`registerService(ServiceOptions serviceOptions)` Like `ConsulClient.registerService(ServiceOptions, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Session>` | ConsulClient.`renewSession(String id)` Like `ConsulClient.renewSession(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<TxnResponse>` | ConsulClient.`transaction(TxnRequest request)` Like `ConsulClient.transaction(TxnRequest, Handler)` but returns a `Future` of the asynchronous result.
    `Future<String>` | ConsulClient.`updateAclToken(AclToken token)` Like `ConsulClient.updateAclToken(AclToken, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`updateCheck(String checkId, CheckStatus status)` Like `ConsulClient.updateCheck(String, CheckStatus, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note)` Like `ConsulClient.updateCheckWithNote(String, CheckStatus, String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition)` Like `ConsulClient.updatePreparedQuery(PreparedQueryDefinition, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`warnCheck(String checkId)` Like `ConsulClient.warnCheck(String, Handler)` but returns a `Future` of the asynchronous result.
    `Future<Void>` | ConsulClient.`warnCheckWithNote(String checkId, String note)` Like `ConsulClient.warnCheckWithNote(String, String, Handler)` but returns a `Future` of the asynchronous result.

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

    Methods in io.vertx.ext.eventbus.bridge.tcp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | TcpEventBusBridge.`close()` Close the current socket.
    `Future<TcpEventBusBridge>` | TcpEventBusBridge.`listen()` Listen on default port 7000
    `Future<TcpEventBusBridge>` | TcpEventBusBridge.`listen(int port)` Listen on specific port
    `Future<TcpEventBusBridge>` | TcpEventBusBridge.`listen(int port, String address)` Listen on specific port and bind to specific address

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

    Methods in io.vertx.ext.healthchecks that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<CheckResult>` | HealthChecks.`checkStatus()` Like `HealthChecks.checkStatus(Handler)` but returns a `Future` of the asynchronous result
    `Future<CheckResult>` | HealthChecks.`checkStatus(String name)` Like `HealthChecks.checkStatus(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | HealthChecks.`invoke(String name)` Like `HealthChecks.invoke(String, Handler)` but with a future of the result.

    Methods in io.vertx.ext.healthchecks with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | CheckResult.`isUp(Future<CheckResult> json)`

    Method parameters in io.vertx.ext.healthchecks with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`resultMapper(java.util.function.Function<CheckResult,Future<CheckResult>> resultMapper)` Sets a function which will be invoked before the `CheckResult` gets written to clients.

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

    Methods in io.vertx.ext.mail that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | MailClient.`close()` Same as `MailClient.close(Handler)` but returning a Future
    `default Future<MailResult>` | MailClient.`sendMail(MailMessage email)` Same as `MailClient.sendMail(MailMessage, Handler)` but returning a Future.

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

    Methods in io.vertx.ext.mongo that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<MongoClientBulkWriteResult>` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations)` Like `MongoClient.bulkWrite(String, List, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientBulkWriteResult>` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions)` Like `MongoClient.bulkWriteWithOptions(String, List, BulkWriteOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`close()` Like `MongoClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoClient.`count(String collection, JsonObject query)` Like `MongoClient.count(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoClient.`countWithOptions(String collection, JsonObject query, CountOptions countOptions)` Like `MongoClient.count(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`createCollection(String collectionName)` Like `MongoClient.createCollection(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions)` Like `MongoClient.createCollection(String, Handler)` but with options and returns a `Future` of the asynchronous result
    `Future<MongoGridFsClient>` | MongoClient.`createDefaultGridFsBucketService()` Like `MongoClient.createDefaultGridFsBucketService(Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoGridFsClient>` | MongoClient.`createGridFsBucketService(String bucketName)` Like `MongoClient.createGridFsBucketService(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`createIndex(String collection, JsonObject key)` Like `MongoClient.createIndex(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`createIndexes(String collection, List<IndexModel> indexes)` Like `MongoClient.createIndexes(String, List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options)` Like `MongoClient.createIndexWithOptions(String, JsonObject, IndexOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoGridFsClient.`delete(String id)` Like `MongoGridFsClient.delete(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonArray>` | MongoClient.`distinct(String collection, String fieldName, String resultClassname)` Like `MongoClient.distinct(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonArray>` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)` Like `MongoClient.distinct(String, String, String, DistinctOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonArray>` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Like `MongoClient.distinctWithQuery(String, String, String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonArray>` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)` Like `MongoClient.distinctWithQuery(String, String, String, JsonObject, DistinctOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName)` Like `MongoGridFsClient.downloadByFileName(WriteStream, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options)` Like `MongoGridFsClient.downloadByFileNameWithOptions(WriteStream, String, GridFsDownloadOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id)` Like `MongoGridFsClient.downloadById(WriteStream, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadFile(String fileName)` Like `MongoGridFsClient.downloadFile(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadFileAs(String fileName, String newFileName)` Like `MongoGridFsClient.downloadFileAs(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | MongoGridFsClient.`downloadFileByID(String id, String fileName)` Like `MongoGridFsClient.downloadFileByID(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoGridFsClient.`drop()` Like `MongoGridFsClient.drop(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`dropCollection(String collection)` Like `MongoClient.dropCollection(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MongoClient.`dropIndex(String collection, String indexName)` Like `MongoClient.dropIndex(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<JsonObject>>` | MongoClient.`find(String collection, JsonObject query)` Like `MongoClient.find(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | MongoGridFsClient.`findAllIds()` Like `MongoGridFsClient.findAllIds(Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | MongoGridFsClient.`findIds(JsonObject query)` Like `MongoGridFsClient.findIds(JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields)` Like `MongoClient.findOne(String, JsonObject, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndDelete(String collection, JsonObject query)` Like `MongoClient.findOneAndDelete(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions)` Like `MongoClient.findOneAndDeleteWithOptions(String, JsonObject, FindOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace)` Like `MongoClient.findOneAndReplace(String, JsonObject, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions)` Like `MongoClient.findOneAndReplaceWithOptions(String, JsonObject, JsonObject, FindOptions, UpdateOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update)` Like `MongoClient.findOneAndUpdate(String, JsonObject, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions)` Like `MongoClient.findOneAndUpdateWithOptions(String, JsonObject, JsonObject, FindOptions, UpdateOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<JsonObject>>` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options)` Like `MongoClient.findWithOptions(String, JsonObject, FindOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<String>>` | MongoClient.`getCollections()` Like `MongoClient.getCollections(Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoClient.`insert(String collection, JsonObject document)` Like `MongoClient.insert(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption)` Like `MongoClient.insertWithOptions(String, JsonObject, WriteOption, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonArray>` | MongoClient.`listIndexes(String collection)` Like `MongoClient.listIndexes(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientDeleteResult>` | MongoClient.`removeDocument(String collection, JsonObject query)` Like `MongoClient.removeDocument(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientDeleteResult>` | MongoClient.`removeDocuments(String collection, JsonObject query)` Like `MongoClient.removeDocuments(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientDeleteResult>` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption)` Like `MongoClient.removeDocumentsWithOptions(String, JsonObject, WriteOption, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientDeleteResult>` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption)` Like `MongoClient.removeDocumentWithOptions(String, JsonObject, WriteOption, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace)` Like `MongoClient.replaceDocuments(String, JsonObject, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options)` Like `MongoClient.replaceDocumentsWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | MongoClient.`runCommand(String commandName, JsonObject command)` Like `MongoClient.runCommand(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoClient.`save(String collection, JsonObject document)` Like `MongoClient.save(String, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption)` Like `MongoClient.saveWithOptions(String, JsonObject, WriteOption, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`updateCollection(String collection, JsonObject query, JsonArray update)` Like `MongoClient.updateCollection(String, JsonObject, JsonArray, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update)` Like `MongoClient.updateCollection(String, JsonObject, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options)` Like `MongoClient.updateCollectionWithOptions(String, JsonObject, JsonArray, UpdateOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<MongoClientUpdateResult>` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options)` Like `MongoClient.updateCollectionWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName)` Like `MongoGridFsClient.uploadByFileName(ReadStream, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options)` Like `MongoGridFsClient.uploadByFileNameWithOptions(ReadStream, String, GridFsUploadOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoGridFsClient.`uploadFile(String fileName)` Like `MongoGridFsClient.uploadFile(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MongoGridFsClient.`uploadFileWithOptions(String fileName, GridFsUploadOptions options)` Like `MongoGridFsClient.uploadFileWithOptions(String, GridFsUploadOptions, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.ext.reactivestreams that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | ReactiveWriteStream.`write(T data)`

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

    Methods in io.vertx.ext.shell that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | ShellServer.`close()` Close the shell server, this is an asynchronous close.
    `default Future<Void>` | ShellServer.`listen()` Start the shell service, this is an asynchronous start.
    `default Future<Void>` | ShellService.`start()` Start the shell service, this is an asynchronous start.
    `default Future<Void>` | ShellService.`stop()` Stop the shell service, this is an asynchronous stop.

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

    Methods in io.vertx.ext.shell.command that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Command>` | CommandRegistry.`registerCommand(Class<? extends AnnotatedCommand> command)` Like `CommandRegistry.registerCommand(Class, Handler)`, without a completion handler.
    `Future<Command>` | CommandRegistry.`registerCommand(Command command)` Like `CommandRegistry.registerCommand(Command, Handler)`, without a completion handler.
    `Future<List<Command>>` | CommandRegistry.`registerCommands(List<Command> commands)` Like `CommandRegistry.registerCommands(List, Handler)`, without a completion handler.
    `Future<Void>` | CommandRegistry.`unregisterCommand(String commandName)` Like `CommandRegistry.unregisterCommand(String, Handler)`, without a completion handler.

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

    Methods in io.vertx.ext.shell.term that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | TermServer.`close()` Close the server.
    `default Future<Void>` | TermServer.`listen()` Bind the term server, the `TermServer.termHandler(Handler)` must be set before.

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

    Methods in io.vertx.ext.stomp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Frame>` | StompClientConnection.`abort(String id)` Aborts a transaction.
    `Future<Frame>` | StompClientConnection.`abort(String id, Map<String,String> headers)` Aborts a transaction.
    `Future<Frame>` | StompClientConnection.`ack(String id)` Sends an acknowledgement for a specific message.
    `Future<Frame>` | StompClientConnection.`ack(String id, String txId)` Sends an acknowledgement for the given frame.
    `Future<Frame>` | StompClientConnection.`beginTX(String id)` Begins a transaction.
    `Future<Frame>` | StompClientConnection.`beginTX(String id, Map<String,String> headers)` Begins a transaction.
    `Future<Void>` | StompServer.`close()` Closes the server.
    `Future<Frame>` | StompClientConnection.`commit(String id)` Commits a transaction.
    `Future<Frame>` | StompClientConnection.`commit(String id, Map<String,String> headers)` Commits a transaction.
    `Future<StompClientConnection>` | StompClient.`connect()` Like `StompClient.connect(Handler)` but returns a `Future` of the asynchronous result
    `Future<StompClientConnection>` | StompClient.`connect(int port, String host)` Like `StompClient.connect(int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<StompClientConnection>` | StompClient.`connect(int port, String host, NetClient net)` Like `StompClient.connect(int, String, NetClient, Handler)` but returns a `Future` of the asynchronous result
    `Future<StompClientConnection>` | StompClient.`connect(NetClient net)` Like `StompClient.connect(NetClient, Handler)` but returns a `Future` of the asynchronous result
    `Future<Frame>` | StompClientConnection.`disconnect()` Disconnects the client.
    `Future<Frame>` | StompClientConnection.`disconnect(Frame frame)` Disconnects the client.
    `Future<StompServer>` | StompServer.`listen()` Connects the STOMP server to the port / host configured in the server options.
    `Future<StompServer>` | StompServer.`listen(int port)` Connects the STOMP server to the given port.
    `Future<StompServer>` | StompServer.`listen(int port, String host)` Connects the STOMP server to the given port / interface.
    `Future<Frame>` | StompClientConnection.`nack(String id)` Sends a non-acknowledgement for the given message.
    `Future<Frame>` | StompClientConnection.`nack(String id, String txId)` Sends a non-acknowledgement for the given frame.
    `Future<Boolean>` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode)` Like `StompServerHandler.onAuthenticationRequest(StompServerConnection, String, String, Handler)` but with a future of the result
    `Future<Frame>` | StompClientConnection.`send(Frame frame)` Sends the given frame to the server.
    `Future<Frame>` | StompClientConnection.`send(Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server.
    `Future<Frame>` | StompClientConnection.`send(String destination, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `Future<Frame>` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `Future<String>` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `Future<String>` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `Future<Frame>` | StompClientConnection.`unsubscribe(String destination)` Un-subscribes from the given destination.
    `Future<Frame>` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers)` Un-subscribes from the given destination.

  - ### Uses of Future in io.vertx.ext.unit.junit

    Constructors in io.vertx.ext.unit.junit with parameters of type Future
    Constructor and Description
    `RunTestOnContext(Future<Vertx> createVertx)` Create a new rule with an asynchronous supplier for creating a Vert.x instance.
    `RunTestOnContext(Future<Vertx> createVertx, java.util.function.BiConsumer<Vertx,java.util.function.Consumer<Void>> closeVertx)` Create a new rule with an asynchronous supplier and consumer for creating and closing a Vert.x instance.

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

    Methods in io.vertx.ext.web that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | RoutingContext.`addEndHandler()` Add an end handler for the request/response context.
    `default Future<Void>` | RoutingContext.`end()` Shortcut to the response end.
    `default Future<Void>` | RoutingContext.`end(Buffer buffer)` Shortcut to the response end.
    `default Future<Void>` | RoutingContext.`end(String chunk)` Shortcut to the response end.
    `default Future<Void>` | RoutingContext.`json(Object json)` Encode an Object to JSON and end the request.
    `default Future<Void>` | RoutingContext.`redirect(String url)` Perform a 302 redirect to `url`.

    Method parameters in io.vertx.ext.web with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `default <T> Route` | Route.`respond(java.util.function.Function<RoutingContext,Future<T>> function)` Append a function request handler to the route handlers list.

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

    Methods in io.vertx.ext.web.api.contract.openapi3 that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<OpenAPI3RouterFactory>` | OpenAPI3RouterFactory.`create(Vertx vertx, String url)` Deprecated.
    `static Future<OpenAPI3RouterFactory>` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth)` Deprecated.

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

    Methods in io.vertx.ext.web.client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<HttpResponse<T>>` | HttpRequest.`send()`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendBuffer(Buffer body)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendForm(MultiMap body)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendForm(MultiMap body, String charset)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendJson(Object body)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendJsonObject(JsonObject body)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendMultipartForm(MultipartForm body)`
    `default Future<HttpResponse<T>>` | HttpRequest.`sendStream(ReadStream<Buffer> body)`

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

    Methods in io.vertx.ext.web.client.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | CacheStore.`delete(io.vertx.ext.web.client.impl.cache.CacheKey key)` Delete a key from the cache.
    `Future<Void>` | CacheStore.`flush()` Delete all entries from the cache.
    `Future<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>` | CacheStore.`get(io.vertx.ext.web.client.impl.cache.CacheKey key)` Retrieve a cached response.
    `Future<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>` | CacheStore.`set(io.vertx.ext.web.client.impl.cache.CacheKey key, io.vertx.ext.web.client.impl.cache.CachedHttpResponse response)` Add a response in the cache with the given key.

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

    Methods in io.vertx.ext.web.codec.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<T>` | BodyStream.`result()`

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

    Methods in io.vertx.ext.web.common.template that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Buffer>` | TemplateEngine.`render(JsonObject context, String templateFileName)`
    `default Future<Buffer>` | TemplateEngine.`render(Map<String,Object> context, String templateFileName)`

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

    Methods in io.vertx.ext.web.handler that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | SessionHandler.`flush(RoutingContext ctx)` Promisified flush.
    `Future<Void>` | SessionHandler.`flush(RoutingContext ctx, boolean ignoreStatus)` Promisified flush.
    `Future<Void>` | SessionHandler.`setUser(RoutingContext context, User user)` Set the user for the session

    Method parameters in io.vertx.ext.web.handler with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `SimpleAuthenticationHandler` | SimpleAuthenticationHandler.`authenticate(java.util.function.Function<RoutingContext,Future<User>> authenticationFunction)` This function will allow you to perform authentication the way you intended to.

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

    Method parameters in io.vertx.ext.web.handler.graphql.dataloader with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <K,V> VertxBatchLoader<K,V>` | VertxBatchLoader.`create(java.util.function.BiFunction<List<K>,org.dataloader.BatchLoaderEnvironment,Future<List<V>>> batchLoader)` Deprecated. Create a new batch loader that works well with `Future` based APIs.
    `static <K,V> VertxBatchLoader<K,V>` | VertxBatchLoader.`create(java.util.function.BiFunction<List<K>,org.dataloader.BatchLoaderEnvironment,Future<List<V>>> batchLoader, java.util.function.Function<org.dataloader.BatchLoaderEnvironment,Context> contextProvider)` Deprecated. Like `VertxBatchLoader.create(BiFunction)`, except the method uses the provided `contextProvider` instead of capturing the current one.
    `static <K,V> VertxMappedBatchLoader<K,V>` | VertxMappedBatchLoader.`create(java.util.function.BiFunction<Set<K>,org.dataloader.BatchLoaderEnvironment,Future<Map<K,V>>> batchLoader)` Deprecated. Create a new batch loader that works well with `Future` based APIs.
    `static <K,V> VertxMappedBatchLoader<K,V>` | VertxMappedBatchLoader.`create(java.util.function.BiFunction<Set<K>,org.dataloader.BatchLoaderEnvironment,Future<Map<K,V>>> batchLoader, java.util.function.Function<org.dataloader.BatchLoaderEnvironment,Context> contextProvider)` Deprecated. Like `VertxMappedBatchLoader.create(BiFunction)`, except the method uses the provided `contextProvider` instead of capturing the current one.

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

    Method parameters in io.vertx.ext.web.handler.graphql.schema with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T> VertxDataFetcher<T>` | VertxDataFetcher.`create(java.util.function.Function<graphql.schema.DataFetchingEnvironment,Future<T>> dataFetcher)` Deprecated. Create a new data fetcher that works well with `Future` based APIs.
    `static <T> VertxDataFetcher<T>` | VertxDataFetcher.`create(java.util.function.Function<graphql.schema.DataFetchingEnvironment,Future<T>> dataFetcher, java.util.function.Function<graphql.schema.DataFetchingEnvironment,Context> contextProvider)` Deprecated. Like `VertxDataFetcher.create(Function)`, except the method uses the provided `contextProvider` instead of capturing the current one.

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

    Methods in io.vertx.ext.web.handler.sockjs that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | SockJSSocket.`end()` Call `SockJSSocket.close()`.
    `Future<Void>` | SockJSSocket.`write(Buffer data)`
    `default Future<Void>` | SockJSSocket.`write(String data)` Write a `String` to the socket, encoded in UTF-8.

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

    Methods in io.vertx.ext.web.openapi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<RouterBuilder>` | SecurityScheme.`bind(java.util.function.Function<JsonObject,Future<AuthenticationHandler>> factory)`
    `static Future<RouterBuilder>` | RouterBuilder.`create(Vertx vertx, String url)` Create a new `RouterBuilder`
    `static Future<RouterBuilder>` | RouterBuilder.`create(Vertx vertx, String url, OpenAPILoaderOptions options)` Create a new `RouterBuilder`

    Method parameters in io.vertx.ext.web.openapi with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<RouterBuilder>` | SecurityScheme.`bind(java.util.function.Function<JsonObject,Future<AuthenticationHandler>> factory)`

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

    Methods in io.vertx.ext.web.openapi.router that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<ValidatableRequest>` | RequestExtractor.`extractValidatableRequest(RoutingContext routingContext, Operation operation)` Extracts and transforms the parameters and the body of an incoming request into a `format` that can be validated by the `RequestValidator`.

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

    Methods in io.vertx.ext.web.sstore that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | SessionStore.`clear()`
    `Future<Void>` | SessionStore.`delete(String cookieValue)`
    `Future<Session>` | SessionStore.`get(String cookieValue)`
    `Future<Void>` | SessionStore.`put(Session session)`
    `Future<Integer>` | SessionStore.`size()`

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

    Methods in io.vertx.grpc.client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default <Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `Future<Void>` | GrpcClient.`close()` Close this client.
    `Future<GrpcClientRequest<Buffer,Buffer>>` | GrpcClient.`request(SocketAddress server)` Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,Resp> Future<GrpcClientRequest<Req,Resp>>` | GrpcClient.`request(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service)` Connect to the remote `server` and create a request for given `method` of a hosted gRPC service.
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`response()`
    `default Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(ReadStream<Req> body)`
    `default Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(Req item)`

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

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

    Methods in io.vertx.grpc.common that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<R,A> Future<R>` | GrpcReadStream.`collecting(java.util.stream.Collector<T,A,R> collector)`
    `Future<Void>` | GrpcReadStream.`end()`
    `Future<Void>` | GrpcWriteStream.`endMessage(GrpcMessage message)` End the stream with an encoded gRPC message.
    `Future<T>` | GrpcReadStream.`last()`
    `Future<Void>` | GrpcWriteStream.`writeMessage(GrpcMessage message)` Write an encoded gRPC message.

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

    Methods in io.vertx.grpc.server that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | GrpcServerResponse.`send(ReadStream<Resp> body)`
    `default Future<Void>` | GrpcServerResponse.`send(Resp item)`

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

    Methods in io.vertx.grpc.stub that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static <I,O> Future<O>` | ClientCalls.`manyToOne(io.vertx.core.impl.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate)`
    `static <I,O> Future<O>` | ClientCalls.`oneToOne(io.vertx.core.impl.ContextInternal ctx, I request, java.util.function.BiConsumer<I,io.grpc.stub.StreamObserver<O>> delegate)`
    `Future<Void>` | GrpcWriteStream.`write(T data)`

    Method parameters in io.vertx.grpc.stub with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <I,O> io.grpc.stub.StreamObserver<I>` | ServerCalls.`manyToOne(io.grpc.stub.StreamObserver<O> response, String compression, java.util.function.Function<ReadStream<I>,Future<O>> delegate)`
    `static <I,O> void` | ServerCalls.`oneToOne(I request, io.grpc.stub.StreamObserver<O> response, String compression, java.util.function.Function<I,Future<O>> delegate)`

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

    Methods in io.vertx.httpproxy that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<ProxyResponse>` | ProxyInterceptor.`handleProxyRequest(ProxyContext context)` Handle the proxy request at the stage of this interceptor.
    `default Future<Void>` | ProxyInterceptor.`handleProxyResponse(ProxyContext context)` Handle the proxy response at the stage of this interceptor.
    `default Future<Void>` | ProxyRequest.`proxy(HttpClientRequest request)` Proxy this request to the origin server using the specified `request` and then send the proxy response.
    `Future<Void>` | ProxyResponse.`send()` Send the proxies response to the user agent.
    `Future<ProxyResponse>` | ProxyRequest.`send(HttpClientRequest request)` Send this request to the origin server using the specified `request`.
    `Future<ProxyResponse>` | ProxyContext.`sendRequest()`
    `Future<Void>` | ProxyContext.`sendResponse()`

    Method parameters in io.vertx.httpproxy with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpProxy` | HttpProxy.`originRequestProvider(java.util.function.BiFunction<HttpServerRequest,HttpClient,Future<HttpClientRequest>> provider)` Set a provider that creates the request to the origin server based the incoming HTTP request.
    `default HttpProxy` | HttpProxy.`originSelector(java.util.function.Function<HttpServerRequest,Future<SocketAddress>> selector)` Set a selector that resolves the origin address based on the incoming HTTP request.

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

    Methods in io.vertx.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Schema>` | SchemaRouter.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser)` Deprecated. Resolve $ref.
    `Future<Void>` | Schema.`validateAsync(Object json)` Deprecated. Validate the json performing an asynchronous validation.

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

    Methods in io.vertx.json.schema.common that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | BaseCombinatorsValidator.`applyDefaultValue(Object obj)`
    `Future<Void>` | DefaultApplier.`applyDefaultValue(Object value)`
    `Future<Object>` | RefSchema.`getOrApplyDefaultAsync(Object input)`
    `Future<Object>` | SchemaInternal.`getOrApplyDefaultAsync(Object input)`
    `Future<Object>` | SchemaImpl.`getOrApplyDefaultAsync(Object input)`
    `Future<Object>` | RecursiveRefSchema.`getOrApplyDefaultAsync(Object input)`
    `Future<Object>` | TrueSchema.`getOrApplyDefaultAsync(Object input)`
    `Future<Object>` | FalseSchema.`getOrApplyDefaultAsync(Object input)`
    `static <T> Future<T>` | FutureUtils.`oneOf(List<Future<T>> results)`
    `Future<Void>` | SchemaRouterImpl.`resolveAllSchemas()`
    `Future<Schema>` | SchemaRouterImpl.`resolveRef(JsonPointer pointer, JsonPointer scope, SchemaParser schemaParser)`
    `protected Future<Void>` | SchemaImpl.`runAsyncValidators(ValidatorContext context, Object in)`
    `Future<Schema>` | SchemaRouterImpl.`solveAllSchemaReferences(Schema schema)` Deeply resolve all references of the provided `schema`
    `Future<Void>` | SchemaImpl.`validateAsync(Object json)`
    `Future<Void>` | TrueSchema.`validateAsync(Object in)`
    `Future<Void>` | FalseSchema.`validateAsync(Object in)`
    `Future<Void>` | RefSchema.`validateAsync(ValidatorContext inContext, Object in)`
    `Future<Void>` | SchemaImpl.`validateAsync(ValidatorContext context, Object in)`
    `Future<Void>` | RecursiveRefSchema.`validateAsync(ValidatorContext inContext, Object in)`
    `Future<Void>` | AsyncValidator.`validateAsync(ValidatorContext context, Object in)` Return a Future that succeed when the validation succeed, while fail with a `ValidationException` when validation fails
    `Future<Void>` | TrueSchema.`validateAsync(ValidatorContext context, Object in)`
    `Future<Void>` | FalseSchema.`validateAsync(ValidatorContext context, Object in)`
    `protected Future<Void>` | BaseMutableStateValidator.`validateSyncAsAsync(ValidatorContext context, Object in)`

    Method parameters in io.vertx.json.schema.common with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Future<T>` | FutureUtils.`oneOf(List<Future<T>> results)`

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

    Methods in io.vertx.junit5 that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | VertxTestContext.`assertComplete(Future<T> fut)` This method allows you to check if a future is completed.
    `<T> Future<T>` | VertxTestContext.`assertFailure(Future<T> fut)` This method allows you to check if a future is failed.

    Methods in io.vertx.junit5 with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | VertxTestContext.`assertComplete(Future<T> fut)` This method allows you to check if a future is completed.
    `<T> Future<T>` | VertxTestContext.`assertFailure(Future<T> fut)` This method allows you to check if a future is failed.

    Constructor parameters in io.vertx.junit5 with type arguments of type Future
    Constructor and Description
    `RunTestOnContext(java.util.function.Supplier<Future<Vertx>> supplier)` Create an instance of this extension that gets a `Vertx` object using the specified asynchronous `supplier`.
    `RunTestOnContext(java.util.function.Supplier<Future<Vertx>> supplier, java.util.function.Function<Vertx,Future<Void>> shutdown)` Create an instance of this extension that gets a `Vertx` object using the specified asynchronous `supplier`.
    `RunTestOnContext(java.util.function.Supplier<Future<Vertx>> supplier, java.util.function.Function<Vertx,Future<Void>> shutdown)` Create an instance of this extension that gets a `Vertx` object using the specified asynchronous `supplier`.

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

    Methods in io.vertx.kafka.admin that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | KafkaAdminClient.`alterConfigs(Map<ConfigResource,Config> configs)` Like `KafkaAdminClient.alterConfigs(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`alterConsumerGroupOffsets(String groupId, Map<TopicPartition,OffsetAndMetadata> offsets)` Like `KafkaAdminClient.alterConsumerGroupOffsets(String, Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`close()` Like `KafkaAdminClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`close(long timeout)` Like `KafkaAdminClient.close(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<org.apache.kafka.common.acl.AclBinding>>` | KafkaAdminClient.`createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings)` Like `KafkaAdminClient.createAcls(List)` (List, Handler)} but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`createPartitions(Map<String,NewPartitions> partitions)` Like `KafkaAdminClient.createPartitions(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`createTopics(List<NewTopic> topics)` Like `KafkaAdminClient.createTopics(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<org.apache.kafka.common.acl.AclBinding>>` | KafkaAdminClient.`deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)` Like `KafkaAdminClient.deleteAcls(List)` (List, Handler)} but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions)` Like `KafkaAdminClient.deleteConsumerGroupOffsets(String, Set, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`deleteConsumerGroups(List<String> groupIds)` Like `KafkaAdminClient.deleteConsumerGroups(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,org.apache.kafka.clients.admin.DeletedRecords>>` | KafkaAdminClient.`deleteRecords(Map<TopicPartition,org.apache.kafka.clients.admin.RecordsToDelete> recordsToDelete)` Like `KafkaAdminClient.deleteRecords(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaAdminClient.`deleteTopics(List<String> topicNames)` Like `KafkaAdminClient.deleteTopics(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<org.apache.kafka.common.acl.AclBinding>>` | KafkaAdminClient.`describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)` Like `KafkaAdminClient.describeAcls(AclBindingFilter, Handler)` but returns a `Future` of the asynchronous result
    `Future<ClusterDescription>` | KafkaAdminClient.`describeCluster()` Like `KafkaAdminClient.describeCluster(Handler)` but returns a `Future` of the asynchronous result
    `Future<ClusterDescription>` | KafkaAdminClient.`describeCluster(DescribeClusterOptions options)` Like `KafkaAdminClient.describeCluster(DescribeClusterOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<ConfigResource,Config>>` | KafkaAdminClient.`describeConfigs(List<ConfigResource> configResources)` Like `KafkaAdminClient.describeConfigs(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,ConsumerGroupDescription>>` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds)` Like `KafkaAdminClient.describeConsumerGroups(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,ConsumerGroupDescription>>` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options)` Like `KafkaAdminClient.describeConsumerGroups(List, DescribeConsumerGroupsOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<Integer,Map<String,org.apache.kafka.clients.admin.LogDirDescription>>>` | KafkaAdminClient.`describeLogDirs(List<Integer> brokers)` Like `KafkaAdminClient.describeLogDirs(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,TopicDescription>>` | KafkaAdminClient.`describeTopics(List<String> topicNames)` Like `KafkaAdminClient.describeTopics(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,TopicDescription>>` | KafkaAdminClient.`describeTopics(List<String> topicNames, DescribeTopicsOptions options)` Like `KafkaAdminClient.describeTopics(List, DescribeTopicsOptions, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Map<TopicPartition,OffsetAndMetadata>>` | KafkaAdminClient.`listConsumerGroupOffsets(String groupId)` Like `KafkaAdminClient.listConsumerGroupOffsets(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,OffsetAndMetadata>>` | KafkaAdminClient.`listConsumerGroupOffsets(String groupId, ListConsumerGroupOffsetsOptions options)` Like `KafkaAdminClient.listConsumerGroupOffsets(String, ListConsumerGroupOffsetsOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<ConsumerGroupListing>>` | KafkaAdminClient.`listConsumerGroups()` Like `KafkaAdminClient.listConsumerGroups(Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,ListOffsetsResultInfo>>` | KafkaAdminClient.`listOffsets(Map<TopicPartition,OffsetSpec> topicPartitionOffsets)` Like `#listOffsets(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Set<String>>` | KafkaAdminClient.`listTopics()` Like `KafkaAdminClient.listTopics(Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.kafka.client.consumer that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | KafkaReadStream.`assign(Set<org.apache.kafka.common.TopicPartition> partitions)` Manually assign a set of partitions to this consumer.
    `Future<Void>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions)` Manually assign a list of partition to this consumer.
    `Future<Void>` | KafkaConsumer.`assign(TopicPartition topicPartition)` Manually assign a partition to this consumer.
    `Future<Set<org.apache.kafka.common.TopicPartition>>` | KafkaReadStream.`assignment()` Like `KafkaReadStream.assignment(Handler)` but returns a `Future` of the asynchronous result
    `Future<Set<TopicPartition>>` | KafkaConsumer.`assignment()` Like `KafkaConsumer.assignment(Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<org.apache.kafka.common.TopicPartition,Long>>` | KafkaReadStream.`beginningOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Like `KafkaReadStream.beginningOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,Long>>` | KafkaConsumer.`beginningOffsets(Set<TopicPartition> topicPartitions)` Like `KafkaConsumer.beginningOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaReadStream.`beginningOffsets(org.apache.kafka.common.TopicPartition topicPartition)` Like `KafkaReadStream.beginningOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition)` Like `KafkaConsumer.beginningOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaReadStream.`close()` Close the stream
    `Future<Void>` | KafkaConsumer.`close()` Close the consumer
    `Future<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>` | KafkaReadStream.`commit()` Commit current offsets for all the subscribed list of topics and partition.
    `Future<Void>` | KafkaConsumer.`commit()` Commit current offsets for all the subscribed list of topics and partition.
    `Future<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>` | KafkaReadStream.`commit(Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata> offsets)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `Future<Map<TopicPartition,OffsetAndMetadata>>` | KafkaConsumer.`commit(Map<TopicPartition,OffsetAndMetadata> offsets)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `Future<org.apache.kafka.clients.consumer.OffsetAndMetadata>` | KafkaReadStream.`committed(org.apache.kafka.common.TopicPartition topicPartition)` Like `KafkaReadStream.committed(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<OffsetAndMetadata>` | KafkaConsumer.`committed(TopicPartition topicPartition)` Like `KafkaConsumer.committed(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<org.apache.kafka.common.TopicPartition,Long>>` | KafkaReadStream.`endOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Like `KafkaReadStream.endOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,Long>>` | KafkaConsumer.`endOffsets(Set<TopicPartition> topicPartitions)` Like `KafkaConsumer.endOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaReadStream.`endOffsets(org.apache.kafka.common.TopicPartition topicPartition)` Like `KafkaReadStream.endOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaConsumer.`endOffsets(TopicPartition topicPartition)` Like `KafkaConsumer.endOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,List<org.apache.kafka.common.PartitionInfo>>>` | KafkaReadStream.`listTopics()` Like `KafkaReadStream.listTopics(Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<String,List<PartitionInfo>>>` | KafkaConsumer.`listTopics()` Like `KafkaConsumer.listTopics(Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndTimestamp>>` | KafkaReadStream.`offsetsForTimes(Map<org.apache.kafka.common.TopicPartition,Long> topicPartitionTimestamps)` Like `KafkaReadStream.offsetsForTimes(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Map<TopicPartition,OffsetAndTimestamp>>` | KafkaConsumer.`offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps)` Like `KafkaConsumer.offsetsForTimes(Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<org.apache.kafka.clients.consumer.OffsetAndTimestamp>` | KafkaReadStream.`offsetsForTimes(org.apache.kafka.common.TopicPartition topicPartition, long timestamp)` Like `KafkaReadStream.offsetsForTimes(TopicPartition, long, Handler)` but returns a `Future` of the asynchronous result
    `Future<OffsetAndTimestamp>` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp)` Like `KafkaConsumer.offsetsForTimes(TopicPartition, Long, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<org.apache.kafka.common.PartitionInfo>>` | KafkaReadStream.`partitionsFor(String topic)` Like `KafkaReadStream.partitionsFor(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<PartitionInfo>>` | KafkaConsumer.`partitionsFor(String topic)` Like `KafkaConsumer.partitionsFor(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaReadStream.`pause(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Suspend fetching from the requested partitions.
    `Future<Void>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions)` Suspend fetching from the requested partitions.
    `Future<Void>` | KafkaConsumer.`pause(TopicPartition topicPartition)` Suspend fetching from the requested partition.
    `Future<Set<org.apache.kafka.common.TopicPartition>>` | KafkaReadStream.`paused()` Like `KafkaReadStream.paused(Handler)` but returns a `Future` of the asynchronous result
    `Future<Set<TopicPartition>>` | KafkaConsumer.`paused()` Like `KafkaConsumer.paused(Handler)` but returns a `Future` of the asynchronous result
    `Future<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>>` | KafkaReadStream.`poll(java.time.Duration timeout)` Like `KafkaReadStream.poll(Duration, Handler)` but returns a `Future` of the asynchronous result
    `Future<KafkaConsumerRecords<K,V>>` | KafkaConsumer.`poll(java.time.Duration timeout)` Like `KafkaConsumer.poll(Duration, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaReadStream.`position(org.apache.kafka.common.TopicPartition partition)` Like `KafkaReadStream.position(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | KafkaConsumer.`position(TopicPartition partition)` Like `KafkaConsumer.position(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaReadStream.`resume(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Resume specified partitions which have been paused with pause.
    `Future<Void>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions)` Resume specified partitions which have been paused with pause.
    `Future<Void>` | KafkaConsumer.`resume(TopicPartition topicPartition)` Resume specified partition which have been paused with pause.
    `Future<Void>` | KafkaReadStream.`seek(org.apache.kafka.common.TopicPartition topicPartition, long offset)` Overrides the fetch offsets that the consumer will use on the next poll.
    `Future<Void>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset)` Overrides the fetch offsets that the consumer will use on the next poll.
    `Future<Void>` | KafkaReadStream.`seekToBeginning(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Seek to the first offset for each of the given partitions.
    `Future<Void>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions)` Seek to the first offset for each of the given partitions.
    `Future<Void>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition)` Seek to the first offset for each of the given partition.
    `Future<Void>` | KafkaReadStream.`seekToEnd(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` Seek to the last offset for each of the given partitions.
    `Future<Void>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions)` Seek to the last offset for each of the given partitions.
    `Future<Void>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition)` Seek to the last offset for each of the given partition.
    `Future<Void>` | KafkaReadStream.`subscribe(Pattern pattern)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `Future<Void>` | KafkaConsumer.`subscribe(Pattern pattern)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `Future<Void>` | KafkaReadStream.`subscribe(Set<String> topics)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `Future<Void>` | KafkaConsumer.`subscribe(Set<String> topics)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `Future<Void>` | KafkaConsumer.`subscribe(String topic)` Subscribe to the given topic to get dynamically assigned partitions.
    `Future<Set<String>>` | KafkaReadStream.`subscription()` Like `KafkaReadStream.subscription(Handler)` but returns a `Future` of the asynchronous result
    `Future<Set<String>>` | KafkaConsumer.`subscription()` Like `KafkaConsumer.subscription(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaReadStream.`unsubscribe()` Unsubscribe from topics currently subscribed with subscribe.
    `Future<Void>` | KafkaConsumer.`unsubscribe()` Unsubscribe from topics currently subscribed with subscribe.

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

    Methods in io.vertx.kafka.client.producer that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | KafkaProducer.`abortTransaction()` Like `KafkaProducer.abortTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaWriteStream.`abortTransaction()` Like `KafkaWriteStream.abortTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaProducer.`beginTransaction()` Like `KafkaProducer.beginTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaWriteStream.`beginTransaction()` Like `KafkaWriteStream.beginTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaProducer.`close()` Close the producer
    `Future<Void>` | KafkaWriteStream.`close()` Close the stream
    `Future<Void>` | KafkaProducer.`close(long timeout)` Like `KafkaProducer.close(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaWriteStream.`close(long timeout)` Like `KafkaWriteStream.close(long, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaProducer.`commitTransaction()` Like `KafkaProducer.commitTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaWriteStream.`commitTransaction()` Like `KafkaWriteStream.commitTransaction(Handler)` but with a future of the result
    `Future<Void>` | KafkaProducer.`flush()` Like `KafkaProducer.flush(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaWriteStream.`flush()` Like `KafkaWriteStream.flush(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | KafkaProducer.`initTransactions()` Like `KafkaProducer.initTransactions(Handler)` but with a future of the result
    `Future<Void>` | KafkaWriteStream.`initTransactions()` Like `KafkaWriteStream.initTransactions(Handler)` but with a future of the result
    `Future<List<PartitionInfo>>` | KafkaProducer.`partitionsFor(String topic)` Like `KafkaProducer.partitionsFor(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<org.apache.kafka.common.PartitionInfo>>` | KafkaWriteStream.`partitionsFor(String topic)` Like `KafkaWriteStream.partitionsFor(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<RecordMetadata>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record)` Asynchronously write a record to a topic
    `Future<org.apache.kafka.clients.producer.RecordMetadata>` | KafkaWriteStream.`send(org.apache.kafka.clients.producer.ProducerRecord<K,V> record)` Asynchronously write a record to a topic

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

    Methods in io.vertx.mqtt that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | MqttServer.`close()` Close the server.
    `Future<MqttConnAckMessage>` | MqttClient.`connect(int port, String host)` Like `MqttClient.connect(int, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<MqttConnAckMessage>` | MqttClient.`connect(int port, String host, String serverName)` Like `MqttClient.connect(int, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MqttClient.`disconnect()` Disconnects from the MQTT server
    `Future<MqttServer>` | MqttServer.`listen()` Start the server listening for incoming connections using the specified options through the constructor
    `Future<MqttServer>` | MqttServer.`listen(int port)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `Future<MqttServer>` | MqttServer.`listen(int port, String host)` Start the server listening for incoming connections on the port and host specified
    `Future<Integer>` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `Future<Integer>` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT client
    `Future<Integer>` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` Like `MqttEndpoint.publish(String, Buffer, MqttQoS, boolean, boolean, int, Handler)` but returns a `Future` of the asynchronous result
    `Future<Integer>` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, io.netty.handler.codec.mqtt.MqttProperties properties)` Like `MqttEndpoint.publish(String, Buffer, MqttQoS, boolean, boolean, int, MqttProperties, Handler)` but returns a `Future` of the asynchronous result
    `Future<Integer>` | MqttClient.`subscribe(Map<String,Integer> topics)` Subscribes to the topics with related QoS levels
    `Future<Integer>` | MqttClient.`subscribe(String topic, int qos)` Subscribes to the topic with a specified QoS level
    `Future<Integer>` | MqttClient.`unsubscribe(List<String> topics)` Unsubscribe from receiving messages on given list of topic
    `Future<Integer>` | MqttClient.`unsubscribe(String topic)` Unsubscribe from receiving messages on given topic

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

    Methods in io.vertx.mssqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect(Vertx vertx, MSSQLConnectOptions connectOptions)` Like `MSSQLConnection.connect(Vertx, MSSQLConnectOptions, Handler)` but returns a `Future` of the asynchronous result
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect(Vertx vertx, String connectionUri)` Like `MSSQLConnection.connect(Vertx, String, Handler)` but returns a `Future` of the asynchronous result

    Method parameters in io.vertx.mssqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLPool` | MSSQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Methods in io.vertx.mysqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | MySQLConnection.`changeUser(MySQLAuthOptions options)` Like `MySQLConnection.changeUser(MySQLAuthOptions, Handler)` but returns a `Future` of the asynchronous result
    `static Future<MySQLConnection>` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions)` Like `MySQLConnection.connect(Vertx, MySQLConnectOptions, Handler)` but returns a `Future` of the asynchronous result
    `static Future<MySQLConnection>` | MySQLConnection.`connect(Vertx vertx, String connectionUri)` Like `MySQLConnection.connect(Vertx, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MySQLConnection.`debug()` Like `MySQLConnection.debug(Handler)` but returns a `Future` of the asynchronous result
    `Future<String>` | MySQLConnection.`getInternalStatistics()` Like `MySQLConnection.getInternalStatistics(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MySQLConnection.`ping()` Like `MySQLConnection.ping(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MySQLConnection.`resetConnection()` Like `MySQLConnection.resetConnection(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MySQLConnection.`setOption(MySQLSetOption option)` Like `MySQLConnection.setOption(MySQLSetOption, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | MySQLConnection.`specifySchema(String schemaName)` Like `MySQLConnection.specifySchema(String, Handler)` but returns a `Future` of the asynchronous result

    Method parameters in io.vertx.mysqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MySQLPool` | MySQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

  - ### Uses of Future in io.vertx.openapi.contract

    Methods in io.vertx.openapi.contract that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<OpenAPIContract>` | OpenAPIContract.`from(Vertx vertx, JsonObject unresolvedContract)` Resolves / dereferences the passed contract and creates an `OpenAPIContract` instance.
    `static Future<OpenAPIContract>` | OpenAPIContract.`from(Vertx vertx, JsonObject unresolvedContract, Map<String,JsonObject> additionalContractFiles)` Resolves / dereferences the passed contract and creates an `OpenAPIContract` instance.
    `static Future<OpenAPIContract>` | OpenAPIContract.`from(Vertx vertx, String unresolvedContractPath)` Resolves / dereferences the passed contract and creates an `OpenAPIContract` instance.
    `static Future<OpenAPIContract>` | OpenAPIContract.`from(Vertx vertx, String unresolvedContractPath, Map<String,String> additionalContractFiles)` Resolves / dereferences the passed contract and creates an `OpenAPIContract` instance.
    `Future<SchemaRepository>` | OpenAPIVersion.`getRepository(Vertx vertx, String baseUri)`
    `Future<JsonObject>` | OpenAPIVersion.`resolve(Vertx vertx, SchemaRepository repo, JsonObject contract)`
    `Future<OutputUnit>` | OpenAPIVersion.`validate(Vertx vertx, SchemaRepository repo, JsonObject contract)`

  - ### Uses of Future in io.vertx.openapi.validation

    Methods in io.vertx.openapi.validation that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<ValidatableRequest>` | RequestUtils.`extract(HttpServerRequest request, Operation operation)` Extracts and transforms the parameters and the body of an incoming request into a `format` that can be validated by the `RequestValidator`.
    `static Future<ValidatableRequest>` | RequestUtils.`extract(HttpServerRequest request, Operation operation, java.util.function.Supplier<Future<Buffer>> bodySupplier)` Like `RequestUtils.extract(HttpServerRequest, Operation)`, but offers to pass a supplier fpr the body.
    `static Future<ValidatableRequest>` | ValidatableRequest.`of(HttpServerRequest request, Operation operation)` Creates a new `ValidatableRequest` object based on the passed `request` and `operation`.
    `Future<Void>` | ValidatedResponse.`send(HttpServerResponse serverResponse)` Add all parameters from the validated response to the passed `HttpServerResponse` and send it.
    `Future<ValidatedRequest>` | RequestValidator.`validate(HttpServerRequest request)` Like `RequestValidator.validate(ValidatableRequest, String)`, but the operationId and `ValidatableRequest` are determined from the passed request.
    `Future<ValidatedRequest>` | RequestValidator.`validate(HttpServerRequest request, String operationId)` Like `RequestValidator.validate(ValidatableRequest, String)`, but `ValidatableRequest` are directly extracted from the passed request.
    `Future<ValidatedRequest>` | RequestValidator.`validate(ValidatableRequest params, String operationId)` Validates the passed request parameters against the operation defined in the related OpenAPI contract.
    `Future<ValidatedResponse>` | ResponseValidator.`validate(ValidatableResponse params, String operationId)` Validates the passed response parameters against the operation defined in the related OpenAPI contract.

    Method parameters in io.vertx.openapi.validation with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<ValidatableRequest>` | RequestUtils.`extract(HttpServerRequest request, Operation operation, java.util.function.Supplier<Future<Buffer>> bodySupplier)` Like `RequestUtils.extract(HttpServerRequest, Operation)`, but offers to pass a supplier fpr the body.

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

    Methods in io.vertx.pgclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<PgConnection>` | PgConnection.`connect(Vertx vertx)` Like `PgConnection.connect(Vertx, Handler)` but returns a `Future` of the asynchronous result
    `static Future<PgConnection>` | PgConnection.`connect(Vertx vertx, PgConnectOptions options)` Like `PgConnection.connect(Vertx, PgConnectOptions, Handler)` but returns a `Future` of the asynchronous result
    `static Future<PgConnection>` | PgConnection.`connect(Vertx vertx, String connectionUri)` Like `PgConnection.connect(Vertx, String, Handler)` but returns a `Future` of the asynchronous result

    Method parameters in io.vertx.pgclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `PgPool` | PgPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Methods in io.vertx.pgclient.pubsub that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | PgSubscriber.`close()` Like `PgSubscriber.close(Handler)` but with a future of the result
    `Future<Void>` | PgSubscriber.`connect()` Like `PgSubscriber.connect(Handler)` but with a future of the result

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

    Methods in io.vertx.rabbitmq that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<ReadStream<RabbitMQConfirmation>>` | RabbitMQClient.`addConfirmListener(int maxQueueSize)` Add a Confirm Listener to the channel.
    `Future<Void>` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple)` Like `RabbitMQClient.basicAck(long, boolean, Handler)` but returns a `Future` of the asynchronous result
    `default Future<RabbitMQConsumer>` | RabbitMQClient.`basicConsumer(String queue)` Like `RabbitMQClient.basicConsumer(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<RabbitMQConsumer>` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options)` Like `RabbitMQClient.basicConsumer(String, QueueOptions, Handler)` but returns a `Future` of the asynchronous result
    `Future<RabbitMQMessage>` | RabbitMQClient.`basicGet(String queue, boolean autoAck)` Like `RabbitMQClient.basicGet(String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue)` Like `RabbitMQClient.basicNack(long, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Like `RabbitMQClient.basicPublish(String, String, BasicProperties, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body)` Like `RabbitMQClient.basicPublish(String, String, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `default Future<Void>` | RabbitMQClient.`basicQos(int prefetchCount)` Like `RabbitMQClient.basicQos(int, Handler)` but returns a `Future` of the asynchronous result
    `default Future<Void>` | RabbitMQClient.`basicQos(int prefetchCount, boolean global)` Like `RabbitMQClient.basicQos(int, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global)` Like `RabbitMQClient.basicQos(int, int, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQConsumer.`cancel()` Stop message consumption from a queue.
    `Future<Void>` | RabbitMQClient.`confirmSelect()` Like `RabbitMQClient.confirmSelect(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey)` Like `RabbitMQClient.exchangeBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)` Like `RabbitMQClient.exchangeBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)` Like `RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)` Like `RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeDelete(String exchange)` Like `RabbitMQClient.exchangeDelete(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey)` Like `RabbitMQClient.exchangeUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)` Like `RabbitMQClient.exchangeUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Long>` | RabbitMQClient.`messageCount(String queue)` Like `RabbitMQClient.messageCount(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Like `#basicPublish(String, String, BasicProperties, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey)` Like `RabbitMQClient.queueBind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Like `RabbitMQClient.queueBind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)` Like `RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)` Like `RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<JsonObject>` | RabbitMQClient.`queueDeclareAuto()` Like `RabbitMQClient.queueDeclareAuto(Handler)` but returns a `Future` of the asynchronous result
    `Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>` | RabbitMQClient.`queueDelete(String queue)` Like `RabbitMQClient.queueDelete(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)` Like `RabbitMQClient.queueDeleteIf(String, boolean, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey)` Like `RabbitMQClient.queueUnbind(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Like `RabbitMQClient.queueUnbind(String, String, String, Map, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`start()` Like `RabbitMQClient.start(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQPublisher.`start()` Like `RabbitMQPublisher.start(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`stop()` Like `RabbitMQClient.stop(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQPublisher.`stop()` Like `RabbitMQPublisher.stop(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`waitForConfirms()` Like `RabbitMQClient.waitForConfirms(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | RabbitMQClient.`waitForConfirms(long timeout)` Like `RabbitMQClient.waitForConfirms(long, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.reactivex that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Future<Void>` | CompletableHelper.`toFuture(Completable maybe)` Adapts an RxJava2 `Completable<T>` to a Vert.x ``.
    `static <T> Future<T>` | MaybeHelper.`toFuture(Maybe<T> maybe)` Adapts an RxJava2 `Maybe<T>` to a Vert.x `Future`.
    `static <T,U> Future<U>` | MaybeHelper.`toFuture(Maybe<T> maybe, java.util.function.Function<T,U> adapter)` Like `MaybeHelper.toFuture(Maybe)` but with an `adapter` of the result.
    `static <T> Future<T>` | SingleHelper.`toFuture(Single<T> single)` Adapts an RxJava2 `Single<T>` to a Vert.x `Future`.
    `static <T,U> Future<U>` | SingleHelper.`toFuture(Single<T> single, java.util.function.Function<T,U> adapter)` Like `SingleHelper.toFuture(Single)` but with an `adapter` of the result.

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

    Methods in io.vertx.reactivex.amqp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | AmqpConnection.`closeFuture()`

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

    Methods in io.vertx.reactivex.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<T>` | Promise.`future()`

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

    Methods in io.vertx.reactivex.core.http with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Single<Integer>` | ServerWebSocket.`rxSetHandshake(Future<Integer> future)` 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(Future<Integer> future)` 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(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.

    Method parameters in io.vertx.reactivex.core.http with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpClient` | HttpClient.`redirectHandler(java.util.function.Function<HttpClientResponse,Future<RequestOptions>> handler)` Set a redirect handler for the http client.

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

    Method parameters in io.vertx.reactivex.db2client with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `DB2Pool` | DB2Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

  - ### Uses of Future in io.vertx.reactivex.ext.auth.otp.hotp

    Methods in io.vertx.reactivex.ext.auth.otp.hotp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | HotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.reactivex.ext.auth.otp.hotp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HotpAuth` | HotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a that can fetch s from a backend given an `identifier` argument.
    `HotpAuth` | HotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a .

  - ### Uses of Future in io.vertx.reactivex.ext.auth.otp.totp

    Methods in io.vertx.reactivex.ext.auth.otp.totp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | TotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.reactivex.ext.auth.otp.totp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `TotpAuth` | TotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a that can fetch s from a backend given an `identifier` argument.
    `TotpAuth` | TotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a .

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

    Method parameters in io.vertx.reactivex.ext.auth.webauthn with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `WebAuthn` | WebAuthn.`authenticatorFetcher(java.util.function.Function<Authenticator,Future<List<Authenticator>>> fetcher)` Provide a that can fetch `Authenticator`s from a backend given the incomplete `Authenticator` argument.
    `WebAuthn` | WebAuthn.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a `Authenticator`.

  - ### Uses of Future in io.vertx.reactivex.ext.bridge

    Methods in io.vertx.reactivex.ext.bridge that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BaseBridgeEvent.`future()`

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

    Methods in io.vertx.reactivex.ext.eventbus.bridge.tcp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

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

    Method parameters in io.vertx.reactivex.ext.healthchecks with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`resultMapper(java.util.function.Function<CheckResult,Future<CheckResult>> resultMapper)` Sets a function which will be invoked before the `CheckResult` gets written to clients.

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

    Method parameters in io.vertx.reactivex.ext.web with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Route` | Route.`respond(java.util.function.Function<RoutingContext,Future<T>> function)` Append a function request handler to the route handlers list.

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

    Method parameters in io.vertx.reactivex.ext.web.handler with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `SimpleAuthenticationHandler` | SimpleAuthenticationHandler.`authenticate(java.util.function.Function<RoutingContext,Future<User>> authenticationFunction)` This function will allow you to perform authentication the way you intended to.

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

    Methods in io.vertx.reactivex.ext.web.handler.graphql that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ApolloWSConnectionInitEvent.`future()` Deprecated.

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

    Methods in io.vertx.reactivex.ext.web.handler.graphql.ws that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ConnectionInitEvent.`future()`

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

    Methods in io.vertx.reactivex.ext.web.handler.sockjs that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

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

    Methods in io.vertx.reactivex.ext.web.openapi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<RouterBuilder>` | SecurityScheme.`bind(java.util.function.Function<JsonObject,Future<AuthenticationHandler>> factory)`
    `Future<RouterBuilder>` | SecurityScheme.`bind(Function<JsonObject,Single<AuthenticationHandler>> factory)`

    Method parameters in io.vertx.reactivex.ext.web.openapi with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<RouterBuilder>` | SecurityScheme.`bind(java.util.function.Function<JsonObject,Future<AuthenticationHandler>> factory)`

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

    Methods in io.vertx.reactivex.grpc.client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>,Single<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `Future<Void>` | GrpcClient.`close()` Close this client.
    `<R,A> Future<R>` | GrpcClientResponse.`collecting(java.util.stream.Collector<Resp,A,R> collector)`
    `Future<Resp>` | GrpcClientResponse.`last()`
    `Future<GrpcClientRequest<Buffer,Buffer>>` | GrpcClient.`request(SocketAddress server)` Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,Resp> Future<GrpcClientRequest<Req,Resp>>` | GrpcClient.`request(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service)` Connect to the remote `server` and create a request for given `method` of a hosted gRPC service.
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`response()`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(Flowable<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(ReadStream<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(Req item)`

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

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

    Methods in io.vertx.reactivex.grpc.common that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<R,A> Future<R>` | GrpcReadStream.`collecting(java.util.stream.Collector<T,A,R> collector)`
    `Future<Void>` | GrpcReadStream.`end()`
    `Future<Void>` | GrpcWriteStream.`endMessage(GrpcMessage message)` End the stream with an encoded gRPC message.
    `Future<T>` | GrpcReadStream.`last()`
    `Future<Void>` | GrpcWriteStream.`writeMessage(GrpcMessage message)` Write an encoded gRPC message.

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

    Methods in io.vertx.reactivex.grpc.server that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<R,A> Future<R>` | GrpcServerRequest.`collecting(java.util.stream.Collector<Req,A,R> collector)`
    `Future<Req>` | GrpcServerRequest.`last()`
    `Future<Void>` | GrpcServerResponse.`send(Flowable<Resp> body)`
    `Future<Void>` | GrpcServerResponse.`send(ReadStream<Resp> body)`
    `Future<Void>` | GrpcServerResponse.`send(Resp item)`

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

    Methods in io.vertx.reactivex.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | Schema.`validateAsync(Object json)` Deprecated.

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

    Method parameters in io.vertx.reactivex.mssqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLPool` | MSSQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.reactivex.mysqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MySQLPool` | MySQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.reactivex.oracleclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `OraclePool` | OraclePool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.reactivex.pgclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `PgPool` | PgPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Methods in io.vertx.reactivex.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` 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> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, Function<SqlConnection,Maybe<T>> function)` 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.

    Method parameters in io.vertx.reactivex.sqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Pool` | Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)` Replace the default pool connection provider, the new `provider` returns a future connection for a given .
    `<T> Maybe<T>` | Pool.`rxWithConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
    `<T> Maybe<T>` | Pool.`rxWithTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
    `<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)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `<T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` 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 Future in io.vertx.redis.client

    Methods in io.vertx.redis.client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Response>` | RedisAPI.`acl(List<String> args)` Redis command acl.
    `default Future<Response>` | RedisAPI.`append(String arg0, String arg1)` Redis command append.
    `default Future<Response>` | RedisAPI.`asking()` Redis command asking.
    `default Future<Response>` | RedisAPI.`auth(List<String> args)` Redis command auth.
    `Future<List<Response>>` | Redis.`batch(List<Request> commands)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `Future<List<Response>>` | RedisConnection.`batch(List<Request> commands)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `default Future<Response>` | RedisAPI.`bfAdd(List<String> args)` Redis command bfAdd.
    `default Future<Response>` | RedisAPI.`bfDebug(List<String> args)` Redis command bfDebug.
    `default Future<Response>` | RedisAPI.`bfExists(List<String> args)` Redis command bfExists.
    `default Future<Response>` | RedisAPI.`bfInfo(List<String> args)` Redis command bfInfo.
    `default Future<Response>` | RedisAPI.`bfInsert(List<String> args)` Redis command bfInsert.
    `default Future<Response>` | RedisAPI.`bfLoadchunk(List<String> args)` Redis command bfLoadchunk.
    `default Future<Response>` | RedisAPI.`bfMadd(List<String> args)` Redis command bfMadd.
    `default Future<Response>` | RedisAPI.`bfMexists(List<String> args)` Redis command bfMexists.
    `default Future<Response>` | RedisAPI.`bfReserve(List<String> args)` Redis command bfReserve.
    `default Future<Response>` | RedisAPI.`bfScandump(List<String> args)` Redis command bfScandump.
    `default Future<Response>` | RedisAPI.`bgrewriteaof()` Redis command bgrewriteaof.
    `default Future<Response>` | RedisAPI.`bgsave(List<String> args)` Redis command bgsave.
    `default Future<Response>` | RedisAPI.`bitcount(List<String> args)` Redis command bitcount.
    `default Future<Response>` | RedisAPI.`bitfield(List<String> args)` Redis command bitfield.
    `default Future<Response>` | RedisAPI.`bitfieldRo(List<String> args)` Redis command bitfieldRo.
    `default Future<Response>` | RedisAPI.`bitop(List<String> args)` Redis command bitop.
    `default Future<Response>` | RedisAPI.`bitpos(List<String> args)` Redis command bitpos.
    `default Future<Response>` | RedisAPI.`blmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Redis command blmove.
    `default Future<Response>` | RedisAPI.`blmpop(List<String> args)` Redis command blmpop.
    `default Future<Response>` | RedisAPI.`blpop(List<String> args)` Redis command blpop.
    `default Future<Response>` | RedisAPI.`brpop(List<String> args)` Redis command brpop.
    `default Future<Response>` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
    `default Future<Response>` | RedisAPI.`bzmpop(List<String> args)` Redis command bzmpop.
    `default Future<Response>` | RedisAPI.`bzpopmax(List<String> args)` Redis command bzpopmax.
    `default Future<Response>` | RedisAPI.`bzpopmin(List<String> args)` Redis command bzpopmin.
    `default Future<Response>` | RedisAPI.`cfAdd(List<String> args)` Redis command cfAdd.
    `default Future<Response>` | RedisAPI.`cfAddnx(List<String> args)` Redis command cfAddnx.
    `default Future<Response>` | RedisAPI.`cfCompact(List<String> args)` Redis command cfCompact.
    `default Future<Response>` | RedisAPI.`cfCount(List<String> args)` Redis command cfCount.
    `default Future<Response>` | RedisAPI.`cfDebug(List<String> args)` Redis command cfDebug.
    `default Future<Response>` | RedisAPI.`cfDel(List<String> args)` Redis command cfDel.
    `default Future<Response>` | RedisAPI.`cfExists(List<String> args)` Redis command cfExists.
    `default Future<Response>` | RedisAPI.`cfInfo(List<String> args)` Redis command cfInfo.
    `default Future<Response>` | RedisAPI.`cfInsert(List<String> args)` Redis command cfInsert.
    `default Future<Response>` | RedisAPI.`cfInsertnx(List<String> args)` Redis command cfInsertnx.
    `default Future<Response>` | RedisAPI.`cfLoadchunk(List<String> args)` Redis command cfLoadchunk.
    `default Future<Response>` | RedisAPI.`cfMexists(List<String> args)` Redis command cfMexists.
    `default Future<Response>` | RedisAPI.`cfReserve(List<String> args)` Redis command cfReserve.
    `default Future<Response>` | RedisAPI.`cfScandump(List<String> args)` Redis command cfScandump.
    `default Future<Response>` | RedisAPI.`client(List<String> args)` Redis command client.
    `Future<Void>` | RedisConnection.`close()` Closes the connection or returns to the pool.
    `default Future<Response>` | RedisAPI.`cluster(List<String> args)` Redis command cluster.
    `default Future<Response>` | RedisAPI.`cmsIncrby(List<String> args)` Redis command cmsIncrby.
    `default Future<Response>` | RedisAPI.`cmsInfo(List<String> args)` Redis command cmsInfo.
    `default Future<Response>` | RedisAPI.`cmsInitbydim(List<String> args)` Redis command cmsInitbydim.
    `default Future<Response>` | RedisAPI.`cmsInitbyprob(List<String> args)` Redis command cmsInitbyprob.
    `default Future<Response>` | RedisAPI.`cmsMerge(List<String> args)` Redis command cmsMerge.
    `default Future<Response>` | RedisAPI.`cmsQuery(List<String> args)` Redis command cmsQuery.
    `default Future<Response>` | RedisAPI.`command(List<String> args)` Redis command command.
    `default Future<Response>` | RedisAPI.`config(List<String> args)` Redis command config.
    `Future<RedisConnection>` | Redis.`connect()` Connects to the redis server.
    `default Future<Response>` | RedisAPI.`copy(List<String> args)` Redis command copy.
    `default Future<Response>` | RedisAPI.`dbsize()` Redis command dbsize.
    `default Future<Response>` | RedisAPI.`debug(List<String> args)` Redis command debug.
    `default Future<Response>` | RedisAPI.`decr(String arg0)` Redis command decr.
    `default Future<Response>` | RedisAPI.`decrby(String arg0, String arg1)` Redis command decrby.
    `default Future<Response>` | RedisAPI.`del(List<String> args)` Redis command del.
    `default Future<Response>` | RedisAPI.`discard()` Redis command discard.
    `default Future<Response>` | RedisAPI.`dump(String arg0)` Redis command dump.
    `default Future<Response>` | RedisAPI.`echo(String arg0)` Redis command echo.
    `default Future<Response>` | RedisAPI.`eval(List<String> args)` Redis command eval.
    `default Future<Response>` | RedisAPI.`evalRo(List<String> args)` Redis command evalRo.
    `default Future<Response>` | RedisAPI.`evalsha(List<String> args)` Redis command evalsha.
    `default Future<Response>` | RedisAPI.`evalshaRo(List<String> args)` Redis command evalshaRo.
    `default Future<Response>` | RedisAPI.`exec()` Redis command exec.
    `default Future<Response>` | RedisAPI.`exists(List<String> args)` Redis command exists.
    `default Future<Response>` | RedisAPI.`expire(List<String> args)` Redis command expire.
    `default Future<Response>` | RedisAPI.`expireat(List<String> args)` Redis command expireat.
    `default Future<Response>` | RedisAPI.`expiretime(String arg0)` Redis command expiretime.
    `default Future<Response>` | RedisAPI.`failover(List<String> args)` Redis command failover.
    `default Future<Response>` | RedisAPI.`fcall(List<String> args)` Redis command fcall.
    `default Future<Response>` | RedisAPI.`fcallRo(List<String> args)` Redis command fcallRo.
    `default Future<Response>` | RedisAPI.`flushall(List<String> args)` Redis command flushall.
    `default Future<Response>` | RedisAPI.`flushdb(List<String> args)` Redis command flushdb.
    `default Future<Response>` | RedisAPI.`ftAdd(List<String> args)` Redis command ftAdd.
    `default Future<Response>` | RedisAPI.`ftAggregate(List<String> args)` Redis command ftAggregate.
    `default Future<Response>` | RedisAPI.`ftAliasadd(List<String> args)` Redis command ftAliasadd.
    `default Future<Response>` | RedisAPI.`ftAliasaddifnx(List<String> args)` Redis command ftAliasaddifnx.
    `default Future<Response>` | RedisAPI.`ftAliasdel(List<String> args)` Redis command ftAliasdel.
    `default Future<Response>` | RedisAPI.`ftAliasdelifx(List<String> args)` Redis command ftAliasdelifx.
    `default Future<Response>` | RedisAPI.`ftAliasupdate(List<String> args)` Redis command ftAliasupdate.
    `default Future<Response>` | RedisAPI.`ftAlter(List<String> args)` Redis command ftAlter.
    `default Future<Response>` | RedisAPI.`ftAlterifnx(List<String> args)` Redis command ftAlterifnx.
    `default Future<Response>` | RedisAPI.`ftConfig(List<String> args)` Redis command ftConfig.
    `default Future<Response>` | RedisAPI.`ftCreate(List<String> args)` Redis command ftCreate.
    `default Future<Response>` | RedisAPI.`ftCreateifnx(List<String> args)` Redis command ftCreateifnx.
    `default Future<Response>` | RedisAPI.`ftCursor(List<String> args)` Redis command ftCursor.
    `default Future<Response>` | RedisAPI.`ftDebug(List<String> args)` Redis command ftDebug.
    `default Future<Response>` | RedisAPI.`ftDel(List<String> args)` Redis command ftDel.
    `default Future<Response>` | RedisAPI.`ftDictadd(List<String> args)` Redis command ftDictadd.
    `default Future<Response>` | RedisAPI.`ftDictdel(List<String> args)` Redis command ftDictdel.
    `default Future<Response>` | RedisAPI.`ftDictdump(List<String> args)` Redis command ftDictdump.
    `default Future<Response>` | RedisAPI.`ftDrop(List<String> args)` Redis command ftDrop.
    `default Future<Response>` | RedisAPI.`ftDropifx(List<String> args)` Redis command ftDropifx.
    `default Future<Response>` | RedisAPI.`ftDropindex(List<String> args)` Redis command ftDropindex.
    `default Future<Response>` | RedisAPI.`ftDropindexifx(List<String> args)` Redis command ftDropindexifx.
    `default Future<Response>` | RedisAPI.`ftExplain(List<String> args)` Redis command ftExplain.
    `default Future<Response>` | RedisAPI.`ftExplaincli(List<String> args)` Redis command ftExplaincli.
    `default Future<Response>` | RedisAPI.`ftGet(List<String> args)` Redis command ftGet.
    `default Future<Response>` | RedisAPI.`ftInfo(List<String> args)` Redis command ftInfo.
    `default Future<Response>` | RedisAPI.`ftList(List<String> args)` Redis command ftList.
    `default Future<Response>` | RedisAPI.`ftMget(List<String> args)` Redis command ftMget.
    `default Future<Response>` | RedisAPI.`ftProfile(List<String> args)` Redis command ftProfile.
    `default Future<Response>` | RedisAPI.`ftSafeadd(List<String> args)` Redis command ftSafeadd.
    `default Future<Response>` | RedisAPI.`ftSearch(List<String> args)` Redis command ftSearch.
    `default Future<Response>` | RedisAPI.`ftSpellcheck(List<String> args)` Redis command ftSpellcheck.
    `default Future<Response>` | RedisAPI.`ftSugadd(List<String> args)` Redis command ftSugadd.
    `default Future<Response>` | RedisAPI.`ftSugdel(List<String> args)` Redis command ftSugdel.
    `default Future<Response>` | RedisAPI.`ftSugget(List<String> args)` Redis command ftSugget.
    `default Future<Response>` | RedisAPI.`ftSuglen(List<String> args)` Redis command ftSuglen.
    `default Future<Response>` | RedisAPI.`ftSynadd(List<String> args)` Redis command ftSynadd.
    `default Future<Response>` | RedisAPI.`ftSyndump(List<String> args)` Redis command ftSyndump.
    `default Future<Response>` | RedisAPI.`ftSynupdate(List<String> args)` Redis command ftSynupdate.
    `default Future<Response>` | RedisAPI.`ftTagvals(List<String> args)` Redis command ftTagvals.
    `default Future<Response>` | RedisAPI.`function(List<String> args)` Redis command function.
    `default Future<Response>` | RedisAPI.`geoadd(List<String> args)` Redis command geoadd.
    `default Future<Response>` | RedisAPI.`geodist(List<String> args)` Redis command geodist.
    `default Future<Response>` | RedisAPI.`geohash(List<String> args)` Redis command geohash.
    `default Future<Response>` | RedisAPI.`geopos(List<String> args)` Redis command geopos.
    `default Future<Response>` | RedisAPI.`georadius(List<String> args)` Redis command georadius.
    `default Future<Response>` | RedisAPI.`georadiusbymember(List<String> args)` Redis command georadiusbymember.
    `default Future<Response>` | RedisAPI.`georadiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
    `default Future<Response>` | RedisAPI.`georadiusRo(List<String> args)` Redis command georadiusRo.
    `default Future<Response>` | RedisAPI.`geosearch(List<String> args)` Redis command geosearch.
    `default Future<Response>` | RedisAPI.`geosearchstore(List<String> args)` Redis command geosearchstore.
    `default Future<Response>` | RedisAPI.`get(String arg0)` Redis command get.
    `default Future<Response>` | RedisAPI.`getbit(String arg0, String arg1)` Redis command getbit.
    `default Future<Response>` | RedisAPI.`getdel(String arg0)` Redis command getdel.
    `default Future<Response>` | RedisAPI.`getex(List<String> args)` Redis command getex.
    `default Future<Response>` | RedisAPI.`getrange(String arg0, String arg1, String arg2)` Redis command getrange.
    `default Future<Response>` | RedisAPI.`getset(String arg0, String arg1)` Redis command getset.
    `default Future<Response>` | RedisAPI.`graphBulk(List<String> args)` Redis command graphBulk.
    `default Future<Response>` | RedisAPI.`graphConfig(List<String> args)` Redis command graphConfig.
    `default Future<Response>` | RedisAPI.`graphDebug(List<String> args)` Redis command graphDebug.
    `default Future<Response>` | RedisAPI.`graphDelete(List<String> args)` Redis command graphDelete.
    `default Future<Response>` | RedisAPI.`graphExplain(List<String> args)` Redis command graphExplain.
    `default Future<Response>` | RedisAPI.`graphList(List<String> args)` Redis command graphList.
    `default Future<Response>` | RedisAPI.`graphProfile(List<String> args)` Redis command graphProfile.
    `default Future<Response>` | RedisAPI.`graphQuery(List<String> args)` Redis command graphQuery.
    `default Future<Response>` | RedisAPI.`graphRoQuery(List<String> args)` Redis command graphRoQuery.
    `default Future<Response>` | RedisAPI.`graphSlowlog(List<String> args)` Redis command graphSlowlog.
    `default Future<Response>` | RedisAPI.`hdel(List<String> args)` Redis command hdel.
    `default Future<Response>` | RedisAPI.`hello(List<String> args)` Redis command hello.
    `default Future<Response>` | RedisAPI.`hexists(String arg0, String arg1)` Redis command hexists.
    `default Future<Response>` | RedisAPI.`hget(String arg0, String arg1)` Redis command hget.
    `default Future<Response>` | RedisAPI.`hgetall(String arg0)` Redis command hgetall.
    `default Future<Response>` | RedisAPI.`hincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
    `default Future<Response>` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
    `default Future<Response>` | RedisAPI.`hkeys(String arg0)` Redis command hkeys.
    `default Future<Response>` | RedisAPI.`hlen(String arg0)` Redis command hlen.
    `default Future<Response>` | RedisAPI.`hmget(List<String> args)` Redis command hmget.
    `default Future<Response>` | RedisAPI.`hmset(List<String> args)` Redis command hmset.
    `default Future<Response>` | RedisAPI.`hrandfield(List<String> args)` Redis command hrandfield.
    `default Future<Response>` | RedisAPI.`hscan(List<String> args)` Redis command hscan.
    `default Future<Response>` | RedisAPI.`hset(List<String> args)` Redis command hset.
    `default Future<Response>` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
    `default Future<Response>` | RedisAPI.`hstrlen(String arg0, String arg1)` Redis command hstrlen.
    `default Future<Response>` | RedisAPI.`hvals(String arg0)` Redis command hvals.
    `default Future<Response>` | RedisAPI.`incr(String arg0)` Redis command incr.
    `default Future<Response>` | RedisAPI.`incrby(String arg0, String arg1)` Redis command incrby.
    `default Future<Response>` | RedisAPI.`incrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
    `default Future<Response>` | RedisAPI.`info(List<String> args)` Redis command info.
    `default Future<Response>` | RedisAPI.`jsonArrappend(List<String> args)` Redis command jsonArrappend.
    `default Future<Response>` | RedisAPI.`jsonArrindex(List<String> args)` Redis command jsonArrindex.
    `default Future<Response>` | RedisAPI.`jsonArrinsert(List<String> args)` Redis command jsonArrinsert.
    `default Future<Response>` | RedisAPI.`jsonArrlen(List<String> args)` Redis command jsonArrlen.
    `default Future<Response>` | RedisAPI.`jsonArrpop(List<String> args)` Redis command jsonArrpop.
    `default Future<Response>` | RedisAPI.`jsonArrtrim(List<String> args)` Redis command jsonArrtrim.
    `default Future<Response>` | RedisAPI.`jsonClear(List<String> args)` Redis command jsonClear.
    `default Future<Response>` | RedisAPI.`jsonDebug(List<String> args)` Redis command jsonDebug.
    `default Future<Response>` | RedisAPI.`jsonDel(List<String> args)` Redis command jsonDel.
    `default Future<Response>` | RedisAPI.`jsonForget(List<String> args)` Redis command jsonForget.
    `default Future<Response>` | RedisAPI.`jsonGet(List<String> args)` Redis command jsonGet.
    `default Future<Response>` | RedisAPI.`jsonMget(List<String> args)` Redis command jsonMget.
    `default Future<Response>` | RedisAPI.`jsonNumincrby(List<String> args)` Redis command jsonNumincrby.
    `default Future<Response>` | RedisAPI.`jsonNummultby(List<String> args)` Redis command jsonNummultby.
    `default Future<Response>` | RedisAPI.`jsonNumpowby(List<String> args)` Redis command jsonNumpowby.
    `default Future<Response>` | RedisAPI.`jsonObjkeys(List<String> args)` Redis command jsonObjkeys.
    `default Future<Response>` | RedisAPI.`jsonObjlen(List<String> args)` Redis command jsonObjlen.
    `default Future<Response>` | RedisAPI.`jsonResp(List<String> args)` Redis command jsonResp.
    `default Future<Response>` | RedisAPI.`jsonSet(List<String> args)` Redis command jsonSet.
    `default Future<Response>` | RedisAPI.`jsonStrappend(List<String> args)` Redis command jsonStrappend.
    `default Future<Response>` | RedisAPI.`jsonStrlen(List<String> args)` Redis command jsonStrlen.
    `default Future<Response>` | RedisAPI.`jsonToggle(List<String> args)` Redis command jsonToggle.
    `default Future<Response>` | RedisAPI.`jsonType(List<String> args)` Redis command jsonType.
    `default Future<Response>` | RedisAPI.`keys(String arg0)` Redis command keys.
    `default Future<Response>` | RedisAPI.`lastsave()` Redis command lastsave.
    `default Future<Response>` | RedisAPI.`latency(List<String> args)` Redis command latency.
    `default Future<Response>` | RedisAPI.`lcs(List<String> args)` Redis command lcs.
    `default Future<Response>` | RedisAPI.`lindex(String arg0, String arg1)` Redis command lindex.
    `default Future<Response>` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
    `default Future<Response>` | RedisAPI.`llen(String arg0)` Redis command llen.
    `default Future<Response>` | RedisAPI.`lmove(String arg0, String arg1, String arg2, String arg3)` Redis command lmove.
    `default Future<Response>` | RedisAPI.`lmpop(List<String> args)` Redis command lmpop.
    `default Future<Response>` | RedisAPI.`lolwut(List<String> args)` Redis command lolwut.
    `default Future<Response>` | RedisAPI.`lpop(List<String> args)` Redis command lpop.
    `default Future<Response>` | RedisAPI.`lpos(List<String> args)` Redis command lpos.
    `default Future<Response>` | RedisAPI.`lpush(List<String> args)` Redis command lpush.
    `default Future<Response>` | RedisAPI.`lpushx(List<String> args)` Redis command lpushx.
    `default Future<Response>` | RedisAPI.`lrange(String arg0, String arg1, String arg2)` Redis command lrange.
    `default Future<Response>` | RedisAPI.`lrem(String arg0, String arg1, String arg2)` Redis command lrem.
    `default Future<Response>` | RedisAPI.`lset(String arg0, String arg1, String arg2)` Redis command lset.
    `default Future<Response>` | RedisAPI.`ltrim(String arg0, String arg1, String arg2)` Redis command ltrim.
    `default Future<Response>` | RedisAPI.`memory(List<String> args)` Redis command memory.
    `default Future<Response>` | RedisAPI.`mget(List<String> args)` Redis command mget.
    `default Future<Response>` | RedisAPI.`migrate(List<String> args)` Redis command migrate.
    `default Future<Response>` | RedisAPI.`module(List<String> args)` Redis command module.
    `default Future<Response>` | RedisAPI.`monitor()` Redis command monitor.
    `default Future<Response>` | RedisAPI.`move(String arg0, String arg1)` Redis command move.
    `default Future<Response>` | RedisAPI.`mset(List<String> args)` Redis command mset.
    `default Future<Response>` | RedisAPI.`msetnx(List<String> args)` Redis command msetnx.
    `default Future<Response>` | RedisAPI.`multi()` Redis command multi.
    `default Future<Response>` | RedisAPI.`object(List<String> args)` Redis command object.
    `default Future<Response>` | RedisAPI.`persist(String arg0)` Redis command persist.
    `default Future<Response>` | RedisAPI.`pexpire(List<String> args)` Redis command pexpire.
    `default Future<Response>` | RedisAPI.`pexpireat(List<String> args)` Redis command pexpireat.
    `default Future<Response>` | RedisAPI.`pexpiretime(String arg0)` Redis command pexpiretime.
    `default Future<Response>` | RedisAPI.`pfadd(List<String> args)` Redis command pfadd.
    `default Future<Response>` | RedisAPI.`pfcount(List<String> args)` Redis command pfcount.
    `default Future<Response>` | RedisAPI.`pfdebug(List<String> args)` Redis command pfdebug.
    `default Future<Response>` | RedisAPI.`pfmerge(List<String> args)` Redis command pfmerge.
    `default Future<Response>` | RedisAPI.`pfselftest()` Redis command pfselftest.
    `default Future<Response>` | RedisAPI.`ping(List<String> args)` Redis command ping.
    `default Future<Response>` | RedisAPI.`psetex(String arg0, String arg1, String arg2)` Redis command psetex.
    `default Future<Response>` | RedisAPI.`psubscribe(List<String> args)` Redis command psubscribe.
    `default Future<Response>` | RedisAPI.`psync(List<String> args)` Redis command psync.
    `default Future<Response>` | RedisAPI.`pttl(String arg0)` Redis command pttl.
    `default Future<Response>` | RedisAPI.`publish(String arg0, String arg1)` Redis command publish.
    `default Future<Response>` | RedisAPI.`pubsub(List<String> args)` Redis command pubsub.
    `default Future<Response>` | RedisAPI.`punsubscribe(List<String> args)` Redis command punsubscribe.
    `default Future<Response>` | RedisAPI.`quit(List<String> args)` Redis command quit.
    `default Future<Response>` | RedisAPI.`randomkey()` Redis command randomkey.
    `default Future<Response>` | RedisAPI.`readonly()` Redis command readonly.
    `default Future<Response>` | RedisAPI.`readwrite()` Redis command readwrite.
    `default Future<Response>` | RedisAPI.`rename(String arg0, String arg1)` Redis command rename.
    `default Future<Response>` | RedisAPI.`renamenx(String arg0, String arg1)` Redis command renamenx.
    `default Future<Response>` | RedisAPI.`replconf(List<String> args)` Redis command replconf.
    `default Future<Response>` | RedisAPI.`replicaof(String arg0, String arg1)` Redis command replicaof.
    `default Future<Response>` | RedisAPI.`reset()` Redis command reset.
    `default Future<Response>` | RedisAPI.`restore(List<String> args)` Redis command restore.
    `default Future<Response>` | RedisAPI.`restoreAsking(List<String> args)` Redis command restoreAsking.
    `default Future<Response>` | RedisAPI.`role()` Redis command role.
    `default Future<Response>` | RedisAPI.`rpop(List<String> args)` Redis command rpop.
    `default Future<Response>` | RedisAPI.`rpoplpush(String arg0, String arg1)` Redis command rpoplpush.
    `default Future<Response>` | RedisAPI.`rpush(List<String> args)` Redis command rpush.
    `default Future<Response>` | RedisAPI.`rpushx(List<String> args)` Redis command rpushx.
    `default Future<Response>` | RedisAPI.`sadd(List<String> args)` Redis command sadd.
    `default Future<Response>` | RedisAPI.`save()` Redis command save.
    `default Future<Response>` | RedisAPI.`scan(List<String> args)` Redis command scan.
    `default Future<Response>` | RedisAPI.`scard(String arg0)` Redis command scard.
    `default Future<Response>` | RedisAPI.`script(List<String> args)` Redis command script.
    `default Future<Response>` | RedisAPI.`sdiff(List<String> args)` Redis command sdiff.
    `default Future<Response>` | RedisAPI.`sdiffstore(List<String> args)` Redis command sdiffstore.
    `default Future<Response>` | RedisAPI.`select(String arg0)` Redis command select.
    `Future<Response>` | RedisAPI.`send(Command cmd, String... args)` Send untyped command to redis.
    `Future<Response>` | Redis.`send(Request command)` Send the given command to the redis server or cluster.
    `Future<Response>` | RedisConnection.`send(Request command)` Send the given command to the redis server or cluster.
    `default Future<Response>` | RedisAPI.`set(List<String> args)` Redis command set.
    `default Future<Response>` | RedisAPI.`setbit(String arg0, String arg1, String arg2)` Redis command setbit.
    `default Future<Response>` | RedisAPI.`setex(String arg0, String arg1, String arg2)` Redis command setex.
    `default Future<Response>` | RedisAPI.`setnx(String arg0, String arg1)` Redis command setnx.
    `default Future<Response>` | RedisAPI.`setrange(String arg0, String arg1, String arg2)` Redis command setrange.
    `default Future<Response>` | RedisAPI.`shutdown(List<String> args)` Redis command shutdown.
    `default Future<Response>` | RedisAPI.`sinter(List<String> args)` Redis command sinter.
    `default Future<Response>` | RedisAPI.`sintercard(List<String> args)` Redis command sintercard.
    `default Future<Response>` | RedisAPI.`sinterstore(List<String> args)` Redis command sinterstore.
    `default Future<Response>` | RedisAPI.`sismember(String arg0, String arg1)` Redis command sismember.
    `default Future<Response>` | RedisAPI.`slaveof(String arg0, String arg1)` Redis command slaveof.
    `default Future<Response>` | RedisAPI.`slowlog(List<String> args)` Redis command slowlog.
    `default Future<Response>` | RedisAPI.`smembers(String arg0)` Redis command smembers.
    `default Future<Response>` | RedisAPI.`smismember(List<String> args)` Redis command smismember.
    `default Future<Response>` | RedisAPI.`smove(String arg0, String arg1, String arg2)` Redis command smove.
    `default Future<Response>` | RedisAPI.`sort(List<String> args)` Redis command sort.
    `default Future<Response>` | RedisAPI.`sortRo(List<String> args)` Redis command sortRo.
    `default Future<Response>` | RedisAPI.`spop(List<String> args)` Redis command spop.
    `default Future<Response>` | RedisAPI.`spublish(String arg0, String arg1)` Redis command spublish.
    `default Future<Response>` | RedisAPI.`srandmember(List<String> args)` Redis command srandmember.
    `default Future<Response>` | RedisAPI.`srem(List<String> args)` Redis command srem.
    `default Future<Response>` | RedisAPI.`sscan(List<String> args)` Redis command sscan.
    `default Future<Response>` | RedisAPI.`ssubscribe(List<String> args)` Redis command ssubscribe.
    `default Future<Response>` | RedisAPI.`strlen(String arg0)` Redis command strlen.
    `default Future<Response>` | RedisAPI.`subscribe(List<String> args)` Redis command subscribe.
    `default Future<Response>` | RedisAPI.`substr(String arg0, String arg1, String arg2)` Redis command substr.
    `default Future<Response>` | RedisAPI.`sunion(List<String> args)` Redis command sunion.
    `default Future<Response>` | RedisAPI.`sunionstore(List<String> args)` Redis command sunionstore.
    `default Future<Response>` | RedisAPI.`sunsubscribe(List<String> args)` Redis command sunsubscribe.
    `default Future<Response>` | RedisAPI.`swapdb(String arg0, String arg1)` Redis command swapdb.
    `default Future<Response>` | RedisAPI.`sync()` Redis command sync.
    `default Future<Response>` | RedisAPI.`time()` Redis command time.
    `default Future<Response>` | RedisAPI.`timeseriesClusterset(List<String> args)` Redis command timeseriesClusterset.
    `default Future<Response>` | RedisAPI.`timeseriesClustersetfromshard(List<String> args)` Redis command timeseriesClustersetfromshard.
    `default Future<Response>` | RedisAPI.`timeseriesHello(List<String> args)` Redis command timeseriesHello.
    `default Future<Response>` | RedisAPI.`timeseriesInfocluster(List<String> args)` Redis command timeseriesInfocluster.
    `default Future<Response>` | RedisAPI.`timeseriesInnercommunication(List<String> args)` Redis command timeseriesInnercommunication.
    `default Future<Response>` | RedisAPI.`timeseriesNetworktest(List<String> args)` Redis command timeseriesNetworktest.
    `default Future<Response>` | RedisAPI.`timeseriesRefreshcluster(List<String> args)` Redis command timeseriesRefreshcluster.
    `default Future<Response>` | RedisAPI.`topkAdd(List<String> args)` Redis command topkAdd.
    `default Future<Response>` | RedisAPI.`topkCount(List<String> args)` Redis command topkCount.
    `default Future<Response>` | RedisAPI.`topkIncrby(List<String> args)` Redis command topkIncrby.
    `default Future<Response>` | RedisAPI.`topkInfo(List<String> args)` Redis command topkInfo.
    `default Future<Response>` | RedisAPI.`topkList(List<String> args)` Redis command topkList.
    `default Future<Response>` | RedisAPI.`topkQuery(List<String> args)` Redis command topkQuery.
    `default Future<Response>` | RedisAPI.`topkReserve(List<String> args)` Redis command topkReserve.
    `default Future<Response>` | RedisAPI.`touch(List<String> args)` Redis command touch.
    `default Future<Response>` | RedisAPI.`tsAdd(List<String> args)` Redis command tsAdd.
    `default Future<Response>` | RedisAPI.`tsAlter(List<String> args)` Redis command tsAlter.
    `default Future<Response>` | RedisAPI.`tsCreate(List<String> args)` Redis command tsCreate.
    `default Future<Response>` | RedisAPI.`tsCreaterule(List<String> args)` Redis command tsCreaterule.
    `default Future<Response>` | RedisAPI.`tsDecrby(List<String> args)` Redis command tsDecrby.
    `default Future<Response>` | RedisAPI.`tsDel(List<String> args)` Redis command tsDel.
    `default Future<Response>` | RedisAPI.`tsDeleterule(List<String> args)` Redis command tsDeleterule.
    `default Future<Response>` | RedisAPI.`tsGet(List<String> args)` Redis command tsGet.
    `default Future<Response>` | RedisAPI.`tsIncrby(List<String> args)` Redis command tsIncrby.
    `default Future<Response>` | RedisAPI.`tsInfo(List<String> args)` Redis command tsInfo.
    `default Future<Response>` | RedisAPI.`tsMadd(List<String> args)` Redis command tsMadd.
    `default Future<Response>` | RedisAPI.`tsMget(List<String> args)` Redis command tsMget.
    `default Future<Response>` | RedisAPI.`tsMrange(List<String> args)` Redis command tsMrange.
    `default Future<Response>` | RedisAPI.`tsMrevrange(List<String> args)` Redis command tsMrevrange.
    `default Future<Response>` | RedisAPI.`tsQueryindex(List<String> args)` Redis command tsQueryindex.
    `default Future<Response>` | RedisAPI.`tsRange(List<String> args)` Redis command tsRange.
    `default Future<Response>` | RedisAPI.`tsRevrange(List<String> args)` Redis command tsRevrange.
    `default Future<Response>` | RedisAPI.`ttl(String arg0)` Redis command ttl.
    `default Future<Response>` | RedisAPI.`type(String arg0)` Redis command type.
    `default Future<Response>` | RedisAPI.`unlink(List<String> args)` Redis command unlink.
    `default Future<Response>` | RedisAPI.`unsubscribe(List<String> args)` Redis command unsubscribe.
    `default Future<Response>` | RedisAPI.`unwatch()` Redis command unwatch.
    `default Future<Response>` | RedisAPI.`wait(String arg0, String arg1)` Redis command wait.
    `default Future<Response>` | RedisAPI.`watch(List<String> args)` Redis command watch.
    `default Future<Response>` | RedisAPI.`xack(List<String> args)` Redis command xack.
    `default Future<Response>` | RedisAPI.`xadd(List<String> args)` Redis command xadd.
    `default Future<Response>` | RedisAPI.`xautoclaim(List<String> args)` Redis command xautoclaim.
    `default Future<Response>` | RedisAPI.`xclaim(List<String> args)` Redis command xclaim.
    `default Future<Response>` | RedisAPI.`xdel(List<String> args)` Redis command xdel.
    `default Future<Response>` | RedisAPI.`xgroup(List<String> args)` Redis command xgroup.
    `default Future<Response>` | RedisAPI.`xinfo(List<String> args)` Redis command xinfo.
    `default Future<Response>` | RedisAPI.`xlen(String arg0)` Redis command xlen.
    `default Future<Response>` | RedisAPI.`xpending(List<String> args)` Redis command xpending.
    `default Future<Response>` | RedisAPI.`xrange(List<String> args)` Redis command xrange.
    `default Future<Response>` | RedisAPI.`xread(List<String> args)` Redis command xread.
    `default Future<Response>` | RedisAPI.`xreadgroup(List<String> args)` Redis command xreadgroup.
    `default Future<Response>` | RedisAPI.`xrevrange(List<String> args)` Redis command xrevrange.
    `default Future<Response>` | RedisAPI.`xsetid(List<String> args)` Redis command xsetid.
    `default Future<Response>` | RedisAPI.`xtrim(List<String> args)` Redis command xtrim.
    `default Future<Response>` | RedisAPI.`zadd(List<String> args)` Redis command zadd.
    `default Future<Response>` | RedisAPI.`zcard(String arg0)` Redis command zcard.
    `default Future<Response>` | RedisAPI.`zcount(String arg0, String arg1, String arg2)` Redis command zcount.
    `default Future<Response>` | RedisAPI.`zdiff(List<String> args)` Redis command zdiff.
    `default Future<Response>` | RedisAPI.`zdiffstore(List<String> args)` Redis command zdiffstore.
    `default Future<Response>` | RedisAPI.`zincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
    `default Future<Response>` | RedisAPI.`zinter(List<String> args)` Redis command zinter.
    `default Future<Response>` | RedisAPI.`zintercard(List<String> args)` Redis command zintercard.
    `default Future<Response>` | RedisAPI.`zinterstore(List<String> args)` Redis command zinterstore.
    `default Future<Response>` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
    `default Future<Response>` | RedisAPI.`zmpop(List<String> args)` Redis command zmpop.
    `default Future<Response>` | RedisAPI.`zmscore(List<String> args)` Redis command zmscore.
    `default Future<Response>` | RedisAPI.`zpopmax(List<String> args)` Redis command zpopmax.
    `default Future<Response>` | RedisAPI.`zpopmin(List<String> args)` Redis command zpopmin.
    `default Future<Response>` | RedisAPI.`zrandmember(List<String> args)` Redis command zrandmember.
    `default Future<Response>` | RedisAPI.`zrange(List<String> args)` Redis command zrange.
    `default Future<Response>` | RedisAPI.`zrangebylex(List<String> args)` Redis command zrangebylex.
    `default Future<Response>` | RedisAPI.`zrangebyscore(List<String> args)` Redis command zrangebyscore.
    `default Future<Response>` | RedisAPI.`zrangestore(List<String> args)` Redis command zrangestore.
    `default Future<Response>` | RedisAPI.`zrank(String arg0, String arg1)` Redis command zrank.
    `default Future<Response>` | RedisAPI.`zrem(List<String> args)` Redis command zrem.
    `default Future<Response>` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
    `default Future<Response>` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
    `default Future<Response>` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
    `default Future<Response>` | RedisAPI.`zrevrange(List<String> args)` Redis command zrevrange.
    `default Future<Response>` | RedisAPI.`zrevrangebylex(List<String> args)` Redis command zrevrangebylex.
    `default Future<Response>` | RedisAPI.`zrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
    `default Future<Response>` | RedisAPI.`zrevrank(String arg0, String arg1)` Redis command zrevrank.
    `default Future<Response>` | RedisAPI.`zscan(List<String> args)` Redis command zscan.
    `default Future<Response>` | RedisAPI.`zscore(String arg0, String arg1)` Redis command zscore.
    `default Future<Response>` | RedisAPI.`zunion(List<String> args)` Redis command zunion.
    `default Future<Response>` | RedisAPI.`zunionstore(List<String> args)` Redis command zunionstore.

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

    Methods in io.vertx.rxjava.amqp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | AmqpConnection.`closeFuture()`

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

    Methods in io.vertx.rxjava.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<T>` | Promise.`future()`

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

    Methods in io.vertx.rxjava.core.http with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Single<Integer>` | ServerWebSocket.`rxSetHandshake(Future<Integer> future)` 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(Future<Integer> future)` 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(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.

    Method parameters in io.vertx.rxjava.core.http with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpClient` | HttpClient.`redirectHandler(java.util.function.Function<HttpClientResponse,Future<RequestOptions>> handler)` Set a redirect handler for the http client.

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

    Method parameters in io.vertx.rxjava.db2client with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `DB2Pool` | DB2Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

  - ### Uses of Future in io.vertx.rxjava.ext.auth.otp.hotp

    Methods in io.vertx.rxjava.ext.auth.otp.hotp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | HotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.rxjava.ext.auth.otp.hotp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HotpAuth` | HotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a that can fetch s from a backend given an `identifier` argument.
    `HotpAuth` | HotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a .

  - ### Uses of Future in io.vertx.rxjava.ext.auth.otp.totp

    Methods in io.vertx.rxjava.ext.auth.otp.totp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | TotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

    Method parameters in io.vertx.rxjava.ext.auth.otp.totp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `TotpAuth` | TotpAuth.`authenticatorFetcher(java.util.function.Function<String,Future<Authenticator>> fetcher)` Provide a that can fetch s from a backend given an `identifier` argument.
    `TotpAuth` | TotpAuth.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a .

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

    Method parameters in io.vertx.rxjava.ext.auth.webauthn with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `WebAuthn` | WebAuthn.`authenticatorFetcher(java.util.function.Function<Authenticator,Future<List<Authenticator>>> fetcher)` Provide a that can fetch `Authenticator`s from a backend given the incomplete `Authenticator` argument.
    `WebAuthn` | WebAuthn.`authenticatorUpdater(java.util.function.Function<Authenticator,Future<Void>> updater)` Provide a that can update or insert a `Authenticator`.

  - ### Uses of Future in io.vertx.rxjava.ext.bridge

    Methods in io.vertx.rxjava.ext.bridge that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BaseBridgeEvent.`future()`

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

    Methods in io.vertx.rxjava.ext.eventbus.bridge.tcp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

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

    Method parameters in io.vertx.rxjava.ext.healthchecks with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`resultMapper(java.util.function.Function<CheckResult,Future<CheckResult>> resultMapper)` Sets a function which will be invoked before the `CheckResult` gets written to clients.

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

    Method parameters in io.vertx.rxjava.ext.web with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Route` | Route.`respond(java.util.function.Function<RoutingContext,Future<T>> function)` Append a function request handler to the route handlers list.

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

    Method parameters in io.vertx.rxjava.ext.web.handler with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `SimpleAuthenticationHandler` | SimpleAuthenticationHandler.`authenticate(java.util.function.Function<RoutingContext,Future<User>> authenticationFunction)` This function will allow you to perform authentication the way you intended to.

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

    Methods in io.vertx.rxjava.ext.web.handler.graphql that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ApolloWSConnectionInitEvent.`future()` Deprecated.

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

    Methods in io.vertx.rxjava.ext.web.handler.graphql.ws that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ConnectionInitEvent.`future()`

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

    Methods in io.vertx.rxjava.ext.web.handler.sockjs that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

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

    Methods in io.vertx.rxjava.grpc.client that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<Req,Resp,T> Future<T>` | GrpcClient.`call(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,Resp>,Future<T>> resultFn)` Call the `service` gRPC service hosted by `server`.
    `Future<Void>` | GrpcClient.`close()` Close this client.
    `<R,A> Future<R>` | GrpcClientResponse.`collecting(java.util.stream.Collector<Resp,A,R> collector)`
    `Future<Resp>` | GrpcClientResponse.`last()`
    `Future<GrpcClientRequest<Buffer,Buffer>>` | GrpcClient.`request(SocketAddress server)` Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,Resp> Future<GrpcClientRequest<Req,Resp>>` | GrpcClient.`request(SocketAddress server, io.grpc.MethodDescriptor<Req,Resp> service)` Connect to the remote `server` and create a request for given `method` of a hosted gRPC service.
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`response()`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(Observable<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(ReadStream<Req> body)`
    `Future<GrpcClientResponse<Req,Resp>>` | GrpcClientRequest.`send(Req item)`

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

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

    Methods in io.vertx.rxjava.grpc.common that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<R,A> Future<R>` | GrpcReadStream.`collecting(java.util.stream.Collector<T,A,R> collector)`
    `Future<Void>` | GrpcReadStream.`end()`
    `Future<Void>` | GrpcWriteStream.`endMessage(GrpcMessage message)` End the stream with an encoded gRPC message.
    `Future<T>` | GrpcReadStream.`last()`
    `Future<Void>` | GrpcWriteStream.`writeMessage(GrpcMessage message)` Write an encoded gRPC message.

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

    Methods in io.vertx.rxjava.grpc.server that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<R,A> Future<R>` | GrpcServerRequest.`collecting(java.util.stream.Collector<Req,A,R> collector)`
    `Future<Req>` | GrpcServerRequest.`last()`
    `Future<Void>` | GrpcServerResponse.`send(Observable<Resp> body)`
    `Future<Void>` | GrpcServerResponse.`send(ReadStream<Resp> body)`
    `Future<Void>` | GrpcServerResponse.`send(Resp item)`

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

    Methods in io.vertx.rxjava.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | Schema.`validateAsync(Object json)` Deprecated.

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

    Method parameters in io.vertx.rxjava.mssqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MSSQLPool` | MSSQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.rxjava.mysqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `MySQLPool` | MySQLPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.rxjava.oracleclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `OraclePool` | OraclePool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Method parameters in io.vertx.rxjava.pgclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `PgPool` | PgPool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)`

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

    Methods in io.vertx.rxjava.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` 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.

    Method parameters in io.vertx.rxjava.sqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Pool` | Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)` Replace the default pool connection provider, the new `provider` returns a future connection for a given .
    `<T> Single<T>` | Pool.`rxWithConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
    `<T> Single<T>` | Pool.`rxWithTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
    `<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)` Execute the given `function` within a transaction.
    `<T> void` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
    `<T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` 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 Future in io.vertx.rxjava3

    Methods in io.vertx.rxjava3 that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Future<Void>` | CompletableHelper.`toFuture(Completable maybe)` Adapts an RxJava2 `Completable<T>` to a Vert.x ``.
    `static <T> Future<T>` | MaybeHelper.`toFuture(Maybe<T> maybe)` Adapts an RxJava2 `Maybe<T>` to a Vert.x `Future`.
    `static <T,U> Future<U>` | MaybeHelper.`toFuture(Maybe<T> maybe, java.util.function.Function<T,U> adapter)` Like `MaybeHelper.toFuture(Maybe)` but with an `adapter` of the result.
    `static <T> Future<T>` | SingleHelper.`toFuture(Single<T> single)` Adapts an RxJava2 `Single<T>` to a Vert.x `Future`.
    `static <T,U> Future<U>` | SingleHelper.`toFuture(Single<T> single, java.util.function.Function<T,U> adapter)` Like `SingleHelper.toFuture(Single)` but with an `adapter` of the result.

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

    Methods in io.vertx.rxjava3.amqp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | AmqpConnection.`closeFuture()`

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

    Methods in io.vertx.rxjava3.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<T>` | Promise.`future()`

  - ### Uses of Future in io.vertx.rxjava3.ext.auth.otp.hotp

    Methods in io.vertx.rxjava3.ext.auth.otp.hotp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | HotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

  - ### Uses of Future in io.vertx.rxjava3.ext.auth.otp.totp

    Methods in io.vertx.rxjava3.ext.auth.otp.totp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Authenticator>` | TotpAuth.`createAuthenticator(String id, OtpKey otpKey)` Creating authenticator from user id and key.

  - ### Uses of Future in io.vertx.rxjava3.ext.bridge

    Methods in io.vertx.rxjava3.ext.bridge that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BaseBridgeEvent.`future()`

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

    Methods in io.vertx.rxjava3.ext.eventbus.bridge.tcp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

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

    Methods in io.vertx.rxjava3.ext.web.handler.graphql that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ApolloWSConnectionInitEvent.`future()` Deprecated.

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

    Methods in io.vertx.rxjava3.ext.web.handler.graphql.ws that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Object>` | ConnectionInitEvent.`future()`

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

    Methods in io.vertx.rxjava3.ext.web.handler.sockjs that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Boolean>` | BridgeEvent.`future()`

  - ### Uses of Future in io.vertx.rxjava3.ext.web.openapi

    Methods in io.vertx.rxjava3.ext.web.openapi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<RouterBuilder>` | SecurityScheme.`bind(java.util.function.Function<JsonObject,Single<AuthenticationHandler>> factory)`

  - ### Uses of Future in io.vertx.rxjava3.json.schema

    Methods in io.vertx.rxjava3.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | Schema.`validateAsync(Object json)` Deprecated.

  - ### Uses of Future in io.vertx.rxjava3.sqlclient

    Methods in io.vertx.rxjava3.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Maybe<T>> function)` Like `Pool.withTransaction(java.util.function.Function<io.vertx.rxjava3.sqlclient.SqlConnection, io.reactivex.rxjava3.core.Maybe<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.

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

    Methods in io.vertx.servicediscovery that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Record>` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter)` Like `ServiceDiscovery.getRecord(Function, Handler)` but returns a `Future` of the asynchronous result
    `Future<Record>` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService)` Like `ServiceDiscovery.getRecords(Function, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<Record>` | ServiceDiscovery.`getRecord(JsonObject filter)` Like `ServiceDiscovery.getRecord(JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Record>` | ServiceDiscovery.`getRecord(String id)` Like `ServiceDiscovery.getRecord(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<Record>>` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter)` Like `ServiceDiscovery.getRecords(Function, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<Record>>` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService)` Like `ServiceDiscovery.getRecords(Function, boolean, Handler)` but returns a `Future` of the asynchronous result
    `Future<List<Record>>` | ServiceDiscovery.`getRecords(JsonObject filter)` Like `ServiceDiscovery.getRecords(JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Record>` | ServiceDiscovery.`publish(Record record)` Like `ServiceDiscovery.publish(Record, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration)` Like `ServiceDiscovery.registerServiceExporter(ServiceExporter, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration)` Like `ServiceDiscovery.registerServiceImporter(ServiceImporter, JsonObject, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | ServiceDiscovery.`unpublish(String id)` Like `ServiceDiscovery.unpublish(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Record>` | ServiceDiscovery.`update(Record record)` Like `ServiceDiscovery.update(Record, Handler)` but returns a `Future` of the asynchronous result

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

    Methods in io.vertx.servicediscovery.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Record>` | ServicePublisher.`publish(Record record)` Like `ServicePublisher.publish(Record, Handler)` but returns a future of the result
    `Future<Void>` | ServicePublisher.`unpublish(String id)` Like `ServicePublisher.unpublish(String, Handler)` but returns a future of the result
    `Future<Record>` | ServicePublisher.`update(Record record)` Like `ServicePublisher.update(Record, Handler)` but returns a future of the result

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

    Methods in io.vertx.servicediscovery.types that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<HttpClient>` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `HttpEndpoint.getClient(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static Future<HttpClient>` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf)` Like `HttpEndpoint.getClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static Future<HttpClient>` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter)` Like `HttpEndpoint.getClient(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<HttpClient>` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)` Like `HttpEndpoint.getClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static <T> Future<MessageConsumer<T>>` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `MessageSource.getConsumer(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static <T> Future<MessageConsumer<T>>` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter)` Like `MessageSource.getConsumer(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<JDBCClient>` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `JDBCDataSource.getJDBCClient(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static Future<JDBCClient>` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration)` Like `JDBCDataSource.getJDBCClient(ServiceDiscovery, Function, JsonObject, Handler)` but returns a future of the result
    `static Future<JDBCClient>` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter)` Like `JDBCDataSource.getJDBCClient(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<JDBCClient>` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)` Like `JDBCDataSource.getJDBCClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static Future<MongoClient>` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `MongoDataSource.getMongoClient(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static Future<MongoClient>` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter)` Like `MongoDataSource.getMongoClient(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<MongoClient>` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)` Like `MongoDataSource.getMongoClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static Future<Redis>` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `RedisDataSource.getRedisClient(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static Future<Redis>` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration)` Like `RedisDataSource.getRedisClient(ServiceDiscovery, Function, JsonObject, Handler)` but returns a future of the result
    `static Future<Redis>` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter)` Like `RedisDataSource.getRedisClient(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<Redis>` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)` Like `RedisDataSource.getRedisClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static Future<WebClient>` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter)` Like `HttpEndpoint.getWebClient(ServiceDiscovery, Function, Handler)` but returns a future of the result
    `static Future<WebClient>` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf)` Like `HttpEndpoint.getWebClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result
    `static Future<WebClient>` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter)` Like `HttpEndpoint.getWebClient(ServiceDiscovery, JsonObject, Handler)` but returns a future of the result
    `static Future<WebClient>` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)` Like `HttpEndpoint.getWebClient(ServiceDiscovery, JsonObject, JsonObject, Handler)` but returns a future of the result

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

    Methods in io.vertx.serviceproxy that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Message<JsonObject>>` | ServiceJWTInterceptor.`apply(Message<JsonObject> msg)` Deprecated.
    `Future<Message<JsonObject>>` | ServiceAuthInterceptor.`apply(Message<JsonObject> msg)` Deprecated.
    `Future<Message<JsonObject>>` | ServiceInterceptor.`intercept(Vertx vertx, Map<String,Object> interceptorContext, Message<JsonObject> body)` Perform the interceptor handling

    Method parameters in io.vertx.serviceproxy with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `ServiceBinder` | ServiceBinder.`addInterceptor(java.util.function.Function<Message<JsonObject>,Future<Message<JsonObject>>> interceptor)` Deprecated.
    `ServiceBinder` | ServiceBinder.`addInterceptor(String action, java.util.function.Function<Message<JsonObject>,Future<Message<JsonObject>>> interceptor)` Deprecated.

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

    Methods in io.vertx.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Transaction>` | SqlConnection.`begin()` Like `SqlConnection.begin(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | PreparedStatement.`close()` Close the prepared query and release its resources.
    `Future<Void>` | RowStream.`close()` Close the stream and release the resources.
    `Future<Void>` | SqlClient.`close()` Like `SqlClient.close(Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | Cursor.`close()` Release the cursor.
    `Future<Void>` | Transaction.`commit()` Commit the current transaction.
    `Future<Void>` | Transaction.`completion()` Return the transaction completion `Future` that succeeds when the transaction commits and fails with `TransactionRollbackException` when the transaction rolls back.
    `Future<T>` | Query.`execute()` Like `Query.execute(Handler)` but returns a `Future` of the asynchronous result
    `Future<T>` | PreparedQuery.`execute(Tuple tuple)` Like `Query.execute(Handler)` but returns a `Future` of the asynchronous result
    `Future<T>` | PreparedQuery.`executeBatch(List<Tuple> batch)` Like `PreparedQuery.executeBatch(List, Handler)` but returns a `Future` of the asynchronous result
    `Future<SqlConnection>` | Pool.`getConnection()` Like `Pool.getConnection(Handler)` but returns a `Future` of the asynchronous result
    `Future<PreparedStatement>` | SqlConnection.`prepare(String sql)` Like `SqlConnection.prepare(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<PreparedStatement>` | SqlConnection.`prepare(String sql, PrepareOptions options)` Like `SqlConnection.prepare(String, Handler)` but returns a `Future` of the asynchronous result
    `Future<RowSet<Row>>` | Cursor.`read(int count)` Like `Cursor.read(int, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | Transaction.`rollback()` Rollback the transaction and release the associated resources.
    `default <T> Future<T>` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Like `Pool.withConnection(Function, Handler)` but returns a `Future` of the asynchronous result
    `default <T> Future<T>` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Like `Pool.withTransaction(Function, Handler)` but returns a `Future` of the asynchronous result.
    `default <T> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` Like `Pool.withTransaction(Function, Handler)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.

    Method parameters in io.vertx.sqlclient with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `Pool` | Pool.`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)` Replace the default pool connection provider, the new `provider` returns a future connection for a given `Context`.
    `default <T> Future<T>` | Pool.`withConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Like `Pool.withConnection(Function, Handler)` but returns a `Future` of the asynchronous result
    `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> Future<T>` | Pool.`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Like `Pool.withTransaction(Function, Handler)` but returns a `Future` of the asynchronous result.
    `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> Future<T>` | Pool.`withTransaction(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,Future<T>> function)` 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 Future in io.vertx.sqlclient.spi

    Methods in io.vertx.sqlclient.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<SqlConnection>` | ConnectionFactory.`connect(Context context)` Create a connection using the given `context`.

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

    Methods in io.vertx.sqlclient.templates that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<R>` | SqlTemplate.`execute(I params)` Like `SqlTemplate.execute(Object, Handler)` but returns a `Future` of the asynchronous result
    `Future<R>` | SqlTemplate.`executeBatch(List<I> batch)` Like `SqlTemplate.executeBatch(List, Handler)` but returns a `Future` of the asynchronous result

Copyright © 2023 Eclipse. All rights reserved.