## 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.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.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.sstore |
  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.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.webauthn |
  io.vertx.reactivex.ext.bridge |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.handler |
  io.vertx.reactivex.ext.web.handler.graphql |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.openapi |
  io.vertx.reactivex.json.schema |
  io.vertx.reactivex.mssqlclient |
  io.vertx.reactivex.mysqlclient |
  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.webauthn |
  io.vertx.rxjava.ext.bridge |
  io.vertx.rxjava.ext.eventbus.bridge.tcp |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.graphql |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.json.schema |
  io.vertx.rxjava.mssqlclient |
  io.vertx.rxjava.mysqlclient |
  io.vertx.rxjava.pgclient |
  io.vertx.rxjava.sqlclient |
  io.vertx.rxjava3 |
  io.vertx.rxjava3.amqp |
  io.vertx.rxjava3.core |
  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.sockjs |
  io.vertx.rxjava3.ext.web.openapi |
  io.vertx.rxjava3.json.schema |
  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
    --- | ---
    `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`.
    `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`.
    `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.
    `<T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Context.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
    `<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
    `<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.
    `Future<MessageConsumer<T>>` | MessageConsumer.`registration()`
    `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<Void>` | FileSystem.`link(String link, String existing)` Like `FileSystem.link(String, String, Handler)` but returns a `Future` of the asynchronous result
    `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<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.
    `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.
    `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<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>` | 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.
    `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.
    `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>` | 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)` Authenticate a user.

  - ### 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)`

  - ### 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)`
    `default Future<Void>` | JDBCUserUtil.`createRolePermission(String role, String permission)`
    `default Future<Void>` | JDBCUserUtil.`createUser(String username, String password)`
    `default Future<Void>` | JDBCUserUtil.`createUserRole(String user, String role)`

  - ### 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
    --- | ---
    `default Future<String>` | MongoUserUtil.`createHashedUser(String username, String hash)`
    `default Future<String>` | MongoUserUtil.`createUser(String username, String password)`
    `default Future<String>` | MongoUserUtil.`createUserRolesAndPermissions(String user, List<String> roles, List<String> permissions)`
    `default Future<String>` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions)` Deprecated. 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
    --- | ---
    `default Future<AccessToken>` | OAuth2Auth.`decodeToken(String token)` Deprecated.
    `default Future<OAuth2Response>` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload)` Deprecated. Fetches a JSON resource using this Access Token.
    `default Future<OAuth2Response>` | AccessToken.`fetch(String resource)` Deprecated. Fetches a JSON resource using this Access Token.
    `default Future<Void>` | AccessToken.`introspect()` Deprecated. Introspect access token.
    `default Future<Void>` | AccessToken.`introspect(String tokenType)` Deprecated. Introspect access token.
    `default Future<AccessToken>` | OAuth2Auth.`introspectToken(String token)` Deprecated.
    `default Future<AccessToken>` | OAuth2Auth.`introspectToken(String token, String tokenType)` Deprecated.
    `default Future<Boolean>` | OAuth2RBAC.`isAuthorized(AccessToken user, String authority)` Deprecated. This method should verify if the user has the given authority and return either a boolean value or an error.
    `default Future<Void>` | OAuth2Auth.`jWKSet()` Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
    `default Future<Void>` | OAuth2Auth.`loadJWK()` Deprecated. Use `OAuth2Auth.jWKSet()`
    `default Future<Void>` | AccessToken.`logout()` Deprecated. Revoke refresh token and calls the logout endpoint.
    `default Future<Void>` | AccessToken.`refresh()` Deprecated. Refresh the access token
    `default Future<User>` | OAuth2Auth.`refresh(User user)` Refresh the current User (access token).
    `default Future<Void>` | AccessToken.`revoke(String token_type)` Deprecated. Revoke access or refresh token
    `default Future<Void>` | OAuth2Auth.`revoke(User user)` Revoke an obtained access token.
    `default Future<Void>` | OAuth2Auth.`revoke(User user, String tokenType)` Revoke an obtained access or refresh token.
    `default Future<JsonObject>` | AccessToken.`userInfo()` Deprecated. Load the user info as per OIDC spec.
    `default 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.sqlclient

    Methods in io.vertx.ext.auth.sqlclient that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default Future<Void>` | SqlUserUtil.`createHashedUser(String username, String hash)`
    `default Future<Void>` | SqlUserUtil.`createRolePermission(String role, String permission)`
    `default Future<Void>` | SqlUserUtil.`createUser(String username, String password)`
    `default 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
    --- | ---
    `default Future<JsonObject>` | WebAuthn.`createCredentialsOptions(JsonObject user)` Same as `WebAuthn.createCredentialsOptions(JsonObject, Handler)` but returning a Future.
    `Future<Boolean>` | MetaDataService.`fetchTOC(String url)` Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
    `default 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)`

  - ### 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<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<Void>` | MongoClient.`createCollection(String collectionName)` Like `MongoClient.createCollection(String, Handler)` but 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.`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<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.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.
    `default 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)` 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)` 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)` 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)` 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)` 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)` 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()`.
    `default 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.sstore

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

  - ### 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<Void>` | ProxyRequest.`proxy(HttpClientRequest inboundRequest)` Proxy this outbound request and response to the origin server using the specified inbound request.
    `Future<Void>` | ProxyResponse.`send()` Send the proxy response to the user agent.
    `Future<ProxyResponse>` | ProxyRequest.`send(HttpClientRequest inboundRequest)` Send this request to the origin server using the specified inbound request.

    Method parameters in io.vertx.httpproxy with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpProxy` | HttpProxy.`originSelector(java.util.function.Function<HttpServerRequest,Future<SocketAddress>> selector)` Set a selector that resolves the origin address based on the outbound 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)` Resolve $ref.
    `Future<Void>` | Schema.`validateAsync(Object json)` 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.

  - ### 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<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<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<Void>` | KafkaAdminClient.`deleteTopics(List<String> topicNames)` Like `KafkaAdminClient.deleteTopics(List, 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<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,TopicDescription>>` | KafkaAdminClient.`describeTopics(List<String> topicNames)` Like `KafkaAdminClient.describeTopics(List, 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>` | 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(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.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.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.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()`

  - ### 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.json.schema

    Methods in io.vertx.reactivex.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | Schema.`validateAsync(Object json)` Validate the json performing an asynchronous validation.

  - ### 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.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

    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.

  - ### 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.`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.`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.`bzpopmax(List<String> args)` Redis command bzpopmax.
    `default Future<Response>` | RedisAPI.`bzpopmin(List<String> args)` Redis command bzpopmin.
    `default Future<Response>` | RedisAPI.`client(List<String> args)` Redis command client.
    `default Future<Response>` | RedisAPI.`cluster(List<String> args)` Redis command cluster.
    `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.`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.`evalsha(List<String> args)` Redis command evalsha.
    `default Future<Response>` | RedisAPI.`exec()` Redis command exec.
    `default Future<Response>` | RedisAPI.`exists(List<String> args)` Redis command exists.
    `default Future<Response>` | RedisAPI.`expire(String arg0, String arg1)` Redis command expire.
    `default Future<Response>` | RedisAPI.`expireat(String arg0, String arg1)` Redis command expireat.
    `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.`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.`get(String arg0)` Redis command get.
    `default Future<Response>` | RedisAPI.`getbit(String arg0, String arg1)` Redis command getbit.
    `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.`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.`host(List<String> args)` Redis command host.
    `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.`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.`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.`lolwut(List<String> args)` Redis command lolwut.
    `default Future<Response>` | RedisAPI.`lpop(String arg0)` Redis command lpop.
    `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(String arg0, String arg1)` Redis command pexpire.
    `default Future<Response>` | RedisAPI.`pexpireat(String arg0, String arg1)` Redis command pexpireat.
    `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.`post(List<String> args)` Redis command post.
    `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(String arg0, String arg1)` 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.`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.`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(String arg0)` 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.`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.`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.`spop(List<String> args)` Redis command spop.
    `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.`stralgo(List<String> args)` Redis command stralgo.
    `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.`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.`touch(List<String> args)` Redis command touch.
    `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.`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(String arg0, String arg1)` 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.`zincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
    `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.`zpopmax(List<String> args)` Redis command zpopmax.
    `default Future<Response>` | RedisAPI.`zpopmin(List<String> args)` Redis command zpopmin.
    `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.`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.`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.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.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()`

  - ### 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.json.schema

    Methods in io.vertx.rxjava.json.schema that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | Schema.`validateAsync(Object json)` Validate the json performing an asynchronous validation.

  - ### 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.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

    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.

  - ### 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.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()`

  - ### 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)` Validate the json performing an asynchronous validation.

  - ### 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)`

    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)`
    `MessageConsumer<JsonObject>` | ProxyHandler.`register(EventBus eventBus, String address, List<java.util.function.Function<Message<JsonObject>,Future<Message<JsonObject>>>> interceptors)` Register the proxy handle on the event bus.
    `MessageConsumer<JsonObject>` | ProxyHandler.`registerLocal(EventBus eventBus, String address, List<java.util.function.Function<Message<JsonObject>,Future<Message<JsonObject>>>> interceptors)` Register the local proxy handle on the event bus.

  - ### 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<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.withTransaction(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

    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.withTransaction(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.

  - ### 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 © 2021 Eclipse. All rights reserved.