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

- Packages that use Future
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.camel |
  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.vault.client |
  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.net.endpoint |
  io.vertx.core.shareddata |
  io.vertx.core.spi.dns |
  io.vertx.core.spi.endpoint |
  io.vertx.core.streams |
  io.vertx.db2client |
  io.vertx.db2client.spi |
  io.vertx.ext.auth.authentication |
  io.vertx.ext.auth.authorization |
  io.vertx.ext.auth.mongo |
  io.vertx.ext.auth.oauth2 |
  io.vertx.ext.auth.oauth2.providers |
  io.vertx.ext.auth.otp.hotp |
  io.vertx.ext.auth.otp.totp |
  io.vertx.ext.auth.sqlclient |
  io.vertx.ext.auth.webauthn |
  io.vertx.ext.consul |
  io.vertx.ext.eventbus.bridge.tcp |
  io.vertx.ext.healthchecks |
  io.vertx.ext.mail |
  io.vertx.ext.mongo |
  io.vertx.ext.reactivestreams |
  io.vertx.ext.shell |
  io.vertx.ext.shell.command |
  io.vertx.ext.shell.term |
  io.vertx.ext.stomp |
  io.vertx.ext.unit.junit |
  io.vertx.ext.web |
  io.vertx.ext.web.client |
  io.vertx.ext.web.client.spi |
  io.vertx.ext.web.codec.spi |
  io.vertx.ext.web.common.template |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.healthchecks |
  io.vertx.ext.web.openapi.router |
  io.vertx.ext.web.sstore |
  io.vertx.grpc.client |
  io.vertx.grpc.common |
  io.vertx.grpc.server |
  io.vertx.grpcio.client |
  io.vertx.httpproxy |
  io.vertx.jdbcclient |
  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.mssqlclient.spi |
  io.vertx.mysqlclient |
  io.vertx.mysqlclient.spi |
  io.vertx.openapi.contract |
  io.vertx.openapi.validation |
  io.vertx.oracleclient |
  io.vertx.oracleclient.spi |
  io.vertx.pgclient |
  io.vertx.pgclient.pubsub |
  io.vertx.pgclient.spi |
  io.vertx.rabbitmq |
  io.vertx.reactivex |
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.cassandra |
  io.vertx.reactivex.circuitbreaker |
  io.vertx.reactivex.config |
  io.vertx.reactivex.core |
  io.vertx.reactivex.core.datagram |
  io.vertx.reactivex.core.dns |
  io.vertx.reactivex.core.eventbus |
  io.vertx.reactivex.core.file |
  io.vertx.reactivex.core.http |
  io.vertx.reactivex.core.net |
  io.vertx.reactivex.core.net.endpoint |
  io.vertx.reactivex.core.parsetools |
  io.vertx.reactivex.core.shareddata |
  io.vertx.reactivex.core.streams |
  io.vertx.reactivex.db2client |
  io.vertx.reactivex.ext.auth.authentication |
  io.vertx.reactivex.ext.auth.authorization |
  io.vertx.reactivex.ext.auth.jwt.authorization |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.auth.oauth2.authorization |
  io.vertx.reactivex.ext.auth.oauth2.providers |
  io.vertx.reactivex.ext.auth.otp.hotp |
  io.vertx.reactivex.ext.auth.otp.totp |
  io.vertx.reactivex.ext.auth.properties |
  io.vertx.reactivex.ext.auth.sqlclient |
  io.vertx.reactivex.ext.auth.webauthn |
  io.vertx.reactivex.ext.bridge |
  io.vertx.reactivex.ext.consul |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.healthchecks |
  io.vertx.reactivex.ext.mail |
  io.vertx.reactivex.ext.mongo |
  io.vertx.reactivex.ext.stomp |
  io.vertx.reactivex.ext.unit.report |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.client |
  io.vertx.reactivex.ext.web.common.template |
  io.vertx.reactivex.ext.web.handler |
  io.vertx.reactivex.ext.web.handler.graphql.ws |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.healthchecks |
  io.vertx.reactivex.ext.web.openapi.router |
  io.vertx.reactivex.ext.web.sstore |
  io.vertx.reactivex.grpc.client |
  io.vertx.reactivex.grpc.common |
  io.vertx.reactivex.grpc.server |
  io.vertx.reactivex.jdbcclient |
  io.vertx.reactivex.kafka.admin |
  io.vertx.reactivex.kafka.client.consumer |
  io.vertx.reactivex.kafka.client.producer |
  io.vertx.reactivex.mqtt |
  io.vertx.reactivex.mssqlclient |
  io.vertx.reactivex.mysqlclient |
  io.vertx.reactivex.openapi.contract |
  io.vertx.reactivex.openapi.validation |
  io.vertx.reactivex.oracleclient |
  io.vertx.reactivex.pgclient |
  io.vertx.reactivex.pgclient.pubsub |
  io.vertx.reactivex.rabbitmq |
  io.vertx.reactivex.redis.client |
  io.vertx.reactivex.servicediscovery |
  io.vertx.reactivex.servicediscovery.spi |
  io.vertx.reactivex.servicediscovery.types |
  io.vertx.reactivex.sqlclient |
  io.vertx.reactivex.sqlclient.templates |
  io.vertx.redis.client |
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.cassandra |
  io.vertx.rxjava.circuitbreaker |
  io.vertx.rxjava.config |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.datagram |
  io.vertx.rxjava.core.dns |
  io.vertx.rxjava.core.eventbus |
  io.vertx.rxjava.core.file |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.core.net |
  io.vertx.rxjava.core.net.endpoint |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.core.shareddata |
  io.vertx.rxjava.core.streams |
  io.vertx.rxjava.db2client |
  io.vertx.rxjava.ext.auth.authentication |
  io.vertx.rxjava.ext.auth.authorization |
  io.vertx.rxjava.ext.auth.jwt.authorization |
  io.vertx.rxjava.ext.auth.oauth2 |
  io.vertx.rxjava.ext.auth.oauth2.authorization |
  io.vertx.rxjava.ext.auth.oauth2.providers |
  io.vertx.rxjava.ext.auth.otp.hotp |
  io.vertx.rxjava.ext.auth.otp.totp |
  io.vertx.rxjava.ext.auth.properties |
  io.vertx.rxjava.ext.auth.sqlclient |
  io.vertx.rxjava.ext.auth.webauthn |
  io.vertx.rxjava.ext.bridge |
  io.vertx.rxjava.ext.consul |
  io.vertx.rxjava.ext.eventbus.bridge.tcp |
  io.vertx.rxjava.ext.healthchecks |
  io.vertx.rxjava.ext.mail |
  io.vertx.rxjava.ext.mongo |
  io.vertx.rxjava.ext.stomp |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.client |
  io.vertx.rxjava.ext.web.common.template |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.graphql.ws |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.ext.web.healthchecks |
  io.vertx.rxjava.ext.web.sstore |
  io.vertx.rxjava.grpc.client |
  io.vertx.rxjava.grpc.common |
  io.vertx.rxjava.grpc.server |
  io.vertx.rxjava.jdbcclient |
  io.vertx.rxjava.kafka.admin |
  io.vertx.rxjava.kafka.client.consumer |
  io.vertx.rxjava.kafka.client.producer |
  io.vertx.rxjava.mqtt |
  io.vertx.rxjava.mssqlclient |
  io.vertx.rxjava.mysqlclient |
  io.vertx.rxjava.oracleclient |
  io.vertx.rxjava.pgclient |
  io.vertx.rxjava.pgclient.pubsub |
  io.vertx.rxjava.rabbitmq |
  io.vertx.rxjava.redis.client |
  io.vertx.rxjava.servicediscovery |
  io.vertx.rxjava.servicediscovery.spi |
  io.vertx.rxjava.servicediscovery.types |
  io.vertx.rxjava.sqlclient |
  io.vertx.rxjava3 |
  io.vertx.servicediscovery |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.types |
  io.vertx.serviceproxy |
  io.vertx.serviceresolver |
  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 | Description
    --- | --- | ---
    `Future<Void>` | AmqpClient.`close()` | Closes the client.
    `Future<Void>` | AmqpConnection.`close()` | Closes the AMQP connection, i.e.
    `Future<Void>` | AmqpReceiver.`close()` | Closes the receiver.
    `Future<Void>` | AmqpSender.`close()` | Closes the sender.
    `Future<Void>` | AmqpConnection.`closeFuture()` |
    `Future<AmqpConnection>` | AmqpClient.`connect()` | Connects to the AMQP broker or router.
    `Future<AmqpSender>` | AmqpConnection.`createAnonymousSender()` | Creates an anonymous sender.
    `Future<AmqpReceiver>` | AmqpConnection.`createDynamicReceiver()` | Creates a dynamic receiver.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<Void>` | AmqpSender.`sendWithAck​(AmqpMessage message)` | Sends an AMQP message and waits for an acknowledgement.

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

    Methods in io.vertx.camel that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | CamelBridge.`start()` | Starts the bridge.
    `Future<Void>` | CamelBridge.`stop()` | Stops the bridge.

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

    Methods in io.vertx.cassandra that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | ResultSet.`all()` | The method should not be used concurrently with others like `ResultSet.fetchNextPage()` or `ResultSet.one()`.
    `Future<Void>` | CassandraClient.`close()` | Closes this client.
    `Future<ResultSet>` | CassandraClient.`execute​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the statement and provide a handler for consuming results.
    `<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)` | Execute a statement and produce a result by applying a collector to result set rows.
    `Future<ResultSet>` | CassandraClient.`execute​(String query)` | Execute the query and provide a handler for consuming results.
    `<R> Future<R>` | CassandraClient.`execute​(String query, java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,​?,​R> collector)` | Execute a query and produce a result by applying a collector to result set rows.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the query and provide a handler for consuming results.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(String query)` | Execute the query and provide a handler for consuming results.
    `Future<ResultSet>` | ResultSet.`fetchNextPage()` |
    `Future<com.datastax.oss.driver.api.core.metadata.Metadata>` | CassandraClient.`metadata()` | Get `Metadata` for the session.
    `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)` | Prepares the provided a `SimpleStatement`.
    `Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>` | CassandraClient.`prepare​(String query)` | Prepares the provided query string.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Executes the given SQL statement which returns the results of the query as a read stream.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(String sql)` | Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

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

    Methods in io.vertx.circuitbreaker that return Future
    Modifier and Type | Method | 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.`execute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(Supplier, 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.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(java.util.function.Supplier<Future<T>> command, java.util.function.Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.

    Methods in io.vertx.circuitbreaker with parameters of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | FailurePolicy.`test​(Future<T> future)` | Invoked by the `CircuitBreaker` when an operation completes.

    Method parameters in io.vertx.circuitbreaker with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(Supplier, Function)` but using the circuit breaker default fallback.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(java.util.function.Supplier<Future<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 | Description
    --- | --- | ---
    `Future<Void>` | ConfigRetriever.`close()` | Closes the retriever.
    `Future<JsonObject>` | ConfigRetriever.`getConfig()` | Reads the configuration from the different `ConfigStore` and computes the final configuration.

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

    Methods in io.vertx.config.consul that return Future
    Modifier and Type | Method | 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 | 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 | 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 | 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 | 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 | Description
    --- | --- | ---
    `Future<Void>` | ConfigStore.`close()` | Closes the configuration store.
    `Future<Buffer>` | ConfigStore.`get()` | Retrieves the configuration store in this store.
    `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 | Description
    --- | --- | ---
    `Future<Void>` | VaultConfigStore.`close()` |
    `Future<Buffer>` | VaultConfigStore.`get()` |

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

    Methods in io.vertx.config.vault.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Auth>` | SlimVaultClient.`createToken​(TokenRequest tokenRequest)` |
    `Future<Void>` | SlimVaultClient.`delete​(String path)` |
    `Future<List<String>>` | SlimVaultClient.`list​(String path)` |
    `Future<Auth>` | SlimVaultClient.`loginWithAppRole​(String roleId, String secretId)` |
    `Future<Auth>` | SlimVaultClient.`loginWithCert()` |
    `Future<Auth>` | SlimVaultClient.`loginWithUserCredentials​(String username, String password)` |
    `Future<Lookup>` | SlimVaultClient.`lookupSelf()` |
    `Future<Secret>` | SlimVaultClient.`read​(String path)` |
    `Future<Auth>` | SlimVaultClient.`renewSelf​(long leaseDurationInSecond)` |
    `Future<Secret>` | SlimVaultClient.`write​(String path, JsonObject secrets)` |

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

    Methods in io.vertx.config.yaml that return Future
    Modifier and Type | Method | 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 | 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 | Description
    --- | --- | ---
    `interface` | `CompositeFuture` | The composite future wraps a list of `futures`, it is useful when several futures needs to be coordinated.
    `interface` | `Timer` | A timer task that can be used as a future.

    Methods in io.vertx.core that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Future<T>` | Future.`andThen​(Completable<? super T> handler)` | Invokes the given `handler` upon completion.
    `default Future<T>` | Future.`andThen​(Handler<AsyncResult<T>> handler)` | Invokes the given `handler` upon completion.
    `Future<Vertx>` | VertxBuilder.`buildClustered()` | Creates a clustered instance.
    `Future<Void>` | Vertx.`close()` | Stop the Vertx instance and release any resources held by it.
    `Future<Void>` | WorkerExecutor.`close()` | Close the executor.
    `static Future<Vertx>` | Vertx.`clusteredVertx​(VertxOptions options)` | Creates a clustered instance using the specified options.
    `default <U> Future<U>` | Future.`compose​(java.util.function.Function<? super T,​Future<U>> mapper)` | Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose​(java.util.function.Function<? super T,​Future<U>> successMapper, java.util.function.Function<Throwable,​Future<U>> failureMapper)` | Compose this future with a `successMapper` and `failureMapper` functions.
    `Future<?>` | AbstractVerticle.`deploy​(Context context)` |
    `Future<?>` | Deployable.`deploy​(Context context)` | Start the deployable.
    `Future<?>` | VerticleBase.`deploy​(Context context)` |
    `default Future<String>` | Vertx.`deployVerticle​(Deployable verticle)` | Deploy a verticle instance that you have created yourself.
    `default Future<String>` | Vertx.`deployVerticle​(Deployable verticle, DeploymentOptions options)` | Like `Vertx.deployVerticle(Deployable)` but `DeploymentOptions` are provided to configure the deployment.
    `Future<String>` | Vertx.`deployVerticle​(Class<? extends Deployable> verticleClass, DeploymentOptions options)` | Like `Vertx.deployVerticle(Deployable, DeploymentOptions)` but `Deployable` instance is created by invoking the default constructor of `verticleClass`.
    `default Future<String>` | Vertx.`deployVerticle​(String name)` | Deploy a verticle instance given a name.
    `Future<String>` | Vertx.`deployVerticle​(String name, DeploymentOptions options)` | Like `Vertx.deployVerticle(Deployable)` but `DeploymentOptions` are provided to configure the deployment.
    `Future<String>` | Vertx.`deployVerticle​(java.util.function.Supplier<? extends Deployable> supplier, DeploymentOptions options)` | Like `Vertx.deployVerticle(Deployable, DeploymentOptions)` but `Deployable` instance is created by invoking the `verticleSupplier`.
    `<U> Future<T>` | Future.`eventually​(java.util.function.Supplier<Future<U>> mapper)` | Compose this future with a `mapper` that will be always be called.
    `default <T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler)` | Invoke `Context.executeBlocking(Callable, boolean)` with order = true.
    `<T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `default <T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `Vertx.executeBlocking(Callable, boolean)` called with ordered = true.
    `default <T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `default <T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `WorkerExecutor.executeBlocking(Callable, boolean)` called with ordered = true.
    `<T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `Future<T>` | Future.`expecting​(Expectation<? super T> expectation)` | Guard the control flow of this future with an expectation.
    `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<? super 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.
    `static <T> Future<T>` | Future.`future​(Handler<Promise<T>> handler)` | Create a promise and pass it to the `handler`, and then returns this future's promise.
    `Future<T>` | Promise.`future()` |
    `<U> Future<U>` | Future.`map​(java.util.function.Function<? super 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`.
    `default Future<T>` | Future.`onComplete​(Completable<? super T> handler)` | Add handlers to be notified on succeeded result and failed result.
    `default Future<T>` | Future.`onComplete​(Handler<? super T> successHandler, Handler<? super Throwable> failureHandler)` | Add handlers to be notified on succeeded result and failed result.
    `Future<T>` | Future.`onComplete​(Handler<AsyncResult<T>> handler)` | Add a handler to be notified of the result.
    `default Future<T>` | Future.`onFailure​(Handler<? super Throwable> handler)` | Add a handler to be notified of the failed result.
    `default Future<T>` | Future.`onSuccess​(Handler<? super 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.
    `Future<?>` | VerticleBase.`start()` | Start the verticle.
    `Future<?>` | VerticleBase.`stop()` | Stop the verticle.
    `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.
    `Future<T>` | Future.`timeout​(long delay, TimeUnit unit)` | Returns a future succeeded or failed with the outcome of this future when it happens before the timeout fires.
    `default <U> Future<U>` | Future.`transform​(java.util.function.BiFunction<? super T,​? super Throwable,​Future<U>> mapper)` | Transform this future with a `mapper` function.
    `<U> Future<U>` | Future.`transform​(java.util.function.Function<AsyncResult<T>,​Future<U>> mapper)` | Transform this future with a `mapper` function.
    `Future<?>` | AbstractVerticle.`undeploy​(Context context)` |
    `default Future<?>` | Deployable.`undeploy​(Context context)` | Stop the deployable.
    `Future<?>` | VerticleBase.`undeploy​(Context context)` |
    `Future<Void>` | Vertx.`undeploy​(String deploymentID)` | Undeploy a verticle deployment.

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

    Method parameters in io.vertx.core with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> CompositeFuture` | Future.`all​(List<? extends Future<?>> futures)` | Like `all(Future, Future)` but with a list of futures.
    `static CompositeFuture` | Future.`any​(List<? extends Future<?>> futures)` | Like `any(Future, Future)` but with a list of futures.
    `default <U> Future<U>` | Future.`compose​(java.util.function.Function<? super T,​Future<U>> mapper)` | Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose​(java.util.function.Function<? super 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.Supplier<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<? super T,​Future<U>> mapper)` | Alias for `compose(Function)`.
    `static CompositeFuture` | Future.`join​(List<? extends Future<?>> futures)` | Like `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.
    `default <U> Future<U>` | Future.`transform​(java.util.function.BiFunction<? super T,​? super Throwable,​Future<U>> mapper)` | Transform this future with a `mapper` function.
    `<U> Future<U>` | Future.`transform​(java.util.function.Function<AsyncResult<T>,​Future<U>> mapper)` | Transform this future with a `mapper` function.

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

    Methods in io.vertx.core.datagram that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String sourceToBlock)` | Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String networkInterface, String sourceToBlock)` | Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
    `Future<Void>` | DatagramSocket.`close()` | Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `Future<DatagramSocket>` | DatagramSocket.`listen​(int port, String host)` | Start listening on the given port and host.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress)` | Joins a multicast group and listens for packets send to it.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Joins a multicast group and listens for packets send to it on the given network interface.
    `Future<Void>` | DatagramSocket.`send​(Buffer packet, int port, String host)` | Write the given `Buffer` to the `SocketAddress`.
    `Future<Void>` | DatagramSocket.`send​(String str, int port, String host)` | Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `Future<Void>` | DatagramSocket.`send​(String str, String enc, int port, String host)` | Write the given `String` to the `SocketAddress` using the given encoding.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress)` | Leaves a multicast group and stops listening for packets send to it.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Leaves a multicast group and stops listening for packets send to it on the given network interface.

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

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

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

    Methods in io.vertx.core.eventbus that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MessageProducer.`close()` | Closes the producer, this method should be called when the message producer is not used anymore.
    `Future<Void>` | MessageConsumer.`completion()` |
    `default <R> Future<Message<R>>` | Message.`replyAndRequest​(Object message)` | Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<R> Future<Message<R>>` | Message.`replyAndRequest​(Object message, DeliveryOptions options)` | Like `Message.replyAndRequest(Object)` but specifying `options` that can be used to configure the delivery.
    `default <T> Future<Message<T>>` | EventBus.`request​(String address, Object message)` | Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> Future<Message<T>>` | EventBus.`request​(String address, Object message, DeliveryOptions options)` | Like `EventBus.request(String, Object)` but specifying `options` that can be used to configure the delivery.
    `Future<Void>` | MessageConsumer.`unregister()` | Unregisters the handler which created this registration
    `Future<Void>` | MessageProducer.`write​(T body)` | Write a message to the event-bus, either sending or publishing.

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

    Methods in io.vertx.core.file that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | FileSystem.`chmod​(String path, String perms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chmodRecursive​(String path, String perms, String dirPerms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chown​(String path, String user, String group)` | Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `Future<Void>` | AsyncFile.`close()` | Close the file.
    `Future<Void>` | FileSystem.`copy​(String from, String to)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copy​(String from, String to, CopyOptions options)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copyRecursive​(String from, String to, boolean recursive)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path)` | Creates an empty file with the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path, String perms)` | Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix, String perms)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String dir, String prefix, String perms)` | Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix)` | Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String dir, String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<Void>` | FileSystem.`delete​(String path)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`deleteRecursive​(String path, boolean recursive)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Boolean>` | FileSystem.`exists​(String path)` | Determines whether the file as specified by the path `path` exists, asynchronously.
    `Future<Void>` | AsyncFile.`flush()` | Flush any writes made to this file to underlying persistent storage.
    `Future<FileSystemProps>` | FileSystem.`fsProps​(String path)` | Returns properties of the file-system being used by the specified `path`, asynchronously.
    `Future<Boolean>` | AsyncFileLock.`isValid()` | A lock remains valid until it is released or the file corresponding `AsyncFile` is closed.
    `Future<Void>` | FileSystem.`link​(String link, String existing)` | Create a hard link on the file system from `link` to `existing`, asynchronously.
    `default Future<AsyncFileLock>` | AsyncFile.`lock()` | Acquire a non-shared lock on the entire file.
    `Future<AsyncFileLock>` | AsyncFile.`lock​(long position, long size, boolean shared)` | Acquire a lock on a portion of this file.
    `Future<FileProps>` | FileSystem.`lprops​(String path)` | Obtain properties for the link represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path, String perms)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path, String perms)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to, CopyOptions options)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<AsyncFile>` | FileSystem.`open​(String path, OpenOptions options)` | Open the file represented by `path`, asynchronously.
    `Future<FileProps>` | FileSystem.`props​(String path)` | Obtain properties for the file represented by `path`, asynchronously.
    `Future<Buffer>` | AsyncFile.`read​(Buffer buffer, int offset, long position, int length)` | Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path, String filter)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<Buffer>` | FileSystem.`readFile​(String path)` | Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
    `Future<String>` | FileSystem.`readSymlink​(String link)` | Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `Future<Void>` | AsyncFileLock.`release()` | Releases this lock;
    `Future<Long>` | AsyncFile.`size()` |
    `Future<Void>` | FileSystem.`symlink​(String link, String existing)` | Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `Future<Void>` | FileSystem.`truncate​(String path, long len)` | Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `Future<Void>` | FileSystem.`unlink​(String link)` | Unlinks the link on the file system represented by the path `link`, asynchronously.
    `default <T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `default <T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.
    `Future<Void>` | AsyncFile.`write​(Buffer buffer, long position)` | Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `Future<Void>` | FileSystem.`writeFile​(String path, Buffer data)` | Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

    Method parameters in io.vertx.core.file with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `default <T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.

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

    Fields in io.vertx.core.http with type parameters of type Future
    Modifier and Type | Field | Description
    --- | --- | ---
    `static java.util.function.Function<HttpClientResponse,​Future<RequestOptions>>` | HttpClientAgent.`DEFAULT_REDIRECT_HANDLER` | Constant containing the default redirect handler of used by the client.

    Methods in io.vertx.core.http that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<ServerWebSocket>` | ServerWebSocketHandshake.`accept()` | Accept the WebSocket and terminate the WebSocket handshake.
    `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.
    `default Future<Void>` | HttpClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `default Future<Void>` | HttpClientConnection.`close()` |
    `default Future<Void>` | HttpConnection.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `default Future<Void>` | HttpServer.`close()` | Close the server.
    `default Future<Void>` | ServerWebSocket.`close()` | Close the WebSocket sending the default close frame.
    `default Future<Void>` | WebSocketBase.`close()` | Close the WebSocket sending the default close frame.
    `default Future<Void>` | WebSocketBase.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `default Future<Void>` | WebSocketBase.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `default Future<Void>` | WebSocketClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `default Future<WebSocket>` | ClientWebSocket.`connect​(int port, String host, String requestURI)` | Connect this WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | ClientWebSocket.`connect​(WebSocketConnectOptions options)` | Connect this WebSocket with the specified options.
    `default Future<WebSocket>` | ClientWebSocket.`connect​(String requestURI)` | Connect this WebSocket at the relative request URI using the default host and port.
    `default Future<WebSocket>` | ClientWebSocket.`connect​(String host, String requestURI)` | Connect this WebSocket to the host and relative request URI and default port.
    `Future<HttpClientConnection>` | HttpClientAgent.`connect​(HttpConnectOptions options)` | Connect to a remote HTTP server with the specific `options`, the connection is un-pooled and the management of the connection is left to the user.
    `Future<HttpClientResponse>` | HttpClientRequest.`connect()` | Create an HTTP tunnel to the server.
    `default Future<WebSocket>` | WebSocketClient.`connect​(int port, String host, String requestURI)` | Connect a WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | WebSocketClient.`connect​(WebSocketConnectOptions options)` | Connect a WebSocket with the specified options.
    `default Future<WebSocket>` | WebSocketClient.`connect​(String requestURI)` | Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `default Future<WebSocket>` | WebSocketClient.`connect​(String host, String requestURI)` | Connect a WebSocket to the default client port and specified host and relative request URI.
    `Future<Void>` | HttpClientRequest.`end()` | Ends the request.
    `Future<Void>` | HttpClientRequest.`end​(Buffer chunk)` | Same as `HttpClientRequest.end()` but writes some data to the request body before ending.
    `Future<Void>` | HttpClientRequest.`end​(String chunk)` | Same as `HttpClientRequest.end(Buffer)` but writes a String in UTF-8 encoding
    `Future<Void>` | HttpClientRequest.`end​(String chunk, String enc)` | Same as `HttpClientRequest.end(Buffer)` but writes a String with the specified encoding
    `Future<Void>` | HttpClientResponse.`end()` | Returns a future signaling when the response has been fully received successfully or failed.
    `Future<Void>` | HttpServerRequest.`end()` | Returns a future signaling when the request has been fully received successfully or failed.
    `Future<Void>` | HttpServerResponse.`end()` | Ends the response.
    `Future<Void>` | HttpServerResponse.`end​(Buffer chunk)` | Same as `HttpServerResponse.end()` but writes some data to the response 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>` | 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>` | WebSocketBase.`end()` | Ends the stream.
    `Future<HttpServer>` | HttpServer.`listen()` | Tell the server to start listening.
    `default Future<HttpServer>` | HttpServer.`listen​(int port)` | Like `HttpServer.listen(int, String)` but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the `HttpServerOptions` that was used when creating the server.
    `default Future<HttpServer>` | HttpServer.`listen​(int port, String host)` | Tell the server to start listening.
    `Future<HttpServer>` | HttpServer.`listen​(SocketAddress address)` | Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `Future<Buffer>` | HttpConnection.`ping​(Buffer data)` | Send a PING frame to the remote endpoint.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, HostAndPort authority, String path, MultiMap headers)` | Push a response to the client.
    `default Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path)` | Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap)` with the host copied from the current request.
    `default Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path, MultiMap headers)` | Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap)` with the host copied from the current request.
    `default Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path)` | Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap)` with no headers.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path, MultiMap headers)` | Deprecated. instead use `HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)`
    `default Future<Void>` | ServerWebSocketHandshake.`reject()` | Reject the WebSocket.
    `Future<Void>` | ServerWebSocketHandshake.`reject​(int status)` | Like `ServerWebSocketHandshake.reject()` but with a `status`.
    `default Future<HttpClientRequest>` | HttpClient.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `default Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `default Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `default Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClient.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientResponse>` | HttpClientRequest.`response()` |
    `default Future<HttpClientResponse>` | HttpClientRequest.`send()` | Send the request with an empty body.
    `default Future<HttpClientResponse>` | HttpClientRequest.`send​(Buffer body)` | Send the request with a buffer `body`.
    `default Future<HttpClientResponse>` | HttpClientRequest.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `default Future<HttpClientResponse>` | HttpClientRequest.`send​(String body)` | Send the request with a string `body`.
    `default Future<Void>` | HttpServerResponse.`send()` | Send the request with an empty body.
    `default Future<Void>` | HttpServerResponse.`send​(Buffer body)` | Send the request with a buffer `body`.
    `default Future<Void>` | HttpServerResponse.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `default Future<Void>` | HttpServerResponse.`send​(String body)` | Send the request with a string `body`.
    `default Future<Void>` | HttpServerResponse.`sendFile​(String filename)` | Send the request with a stream `body`.
    `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.
    `default Future<Void>` | HttpClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `default Future<Void>` | HttpClientConnection.`shutdown()` |
    `Future<Void>` | HttpClientConnection.`shutdown​(long timeout, TimeUnit unit)` |
    `default Future<Void>` | HttpConnection.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpConnection.`shutdown​(long timeout, TimeUnit unit)` | Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `default Future<Void>` | HttpServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `default Future<Void>` | WebSocketBase.`shutdown()` | Like `WebSocketBase.shutdown(long, TimeUnit, short, String)` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `default Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown(long, TimeUnit, short, String)` with the status code `1000` and a `null` reason.
    `default Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown(long, TimeUnit, short, String)` with a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `default Future<Void>` | WebSocketBase.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown(long, TimeUnit, short, String)` with a 30 seconds timeout and a `null` reason.
    `default Future<Void>` | WebSocketBase.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown(long, TimeUnit, short, String)` with a 30 seconds timeout.
    `default Future<Void>` | WebSocketClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | WebSocketClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpServerFileUpload.`streamToFileSystem​(String filename)` | Stream the content of this upload to the given file on storage.
    `Future<NetSocket>` | HttpServerRequest.`toNetSocket()` | Establish a TCP tunnel with the client.
    `Future<ServerWebSocket>` | HttpServerRequest.`toWebSocket()` | Upgrade the connection of the current request to a WebSocket.
    `Future<Void>` | HttpConnection.`updateSettings​(Http2Settings settings)` | Send to the remote endpoint an update of this endpoint settings
    `default Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `default Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `default Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | HttpClientRequest.`write​(String chunk)` | Write a `String` to the request body, encoded as UTF-8.
    `Future<Void>` | HttpClientRequest.`write​(String chunk, String enc)` | Write a `String` to the request body, encoded using the encoding `enc`.
    `Future<Void>` | HttpServerResponse.`write​(String chunk)` | Write a `String` to the response body, encoded in UTF-8.
    `Future<Void>` | HttpServerResponse.`write​(String chunk, String enc)` | Write a `String` to the response body, encoded using the encoding `enc`.
    `Future<Void>` | WebSocketBase.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | HttpServerResponse.`writeContinue()` | Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
    `Future<Void>` | HttpClientRequest.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
    `default Future<Void>` | HttpClientRequest.`writeCustomFrame​(HttpFrame frame)` | Like `HttpClientRequest.writeCustomFrame(int, int, Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
    `default Future<Void>` | HttpServerResponse.`writeCustomFrame​(HttpFrame frame)` | Like `HttpServerResponse.writeCustomFrame(int, int, Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeEarlyHints​(MultiMap headers)` | Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
    `Future<Void>` | WebSocketBase.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocketBase.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | WebSocketBase.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | WebSocketBase.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | WebSocketBase.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.

    Method parameters in io.vertx.core.http with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `HttpClientRequest` | HttpClientRequest.`redirectHandler​(java.util.function.Function<HttpClientResponse,​Future<HttpClientRequest>> handler)` |
    `HttpClientBuilder` | HttpClientBuilder.`withRedirectHandler​(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 | Description
    --- | --- | ---
    `default Future<Void>` | NetClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `default Future<Void>` | NetServer.`close()` | Close the server.
    `Future<Void>` | NetSocket.`close()` | Close the socket
    `Future<NetSocket>` | NetClient.`connect​(int port, String host)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(int port, String host, String serverName)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(ConnectOptions connectOptions)` | Open a connection to a server at the specific `connectOptions`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress, String serverName)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<Void>` | NetSocket.`end()` | Calls `NetSocket.close()`
    `Future<NetServer>` | NetServer.`listen()` | Start listening on the port and host as configured in the `NetServerOptions` used when creating the server.
    `default Future<NetServer>` | NetServer.`listen​(int port)` | Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default Future<NetServer>` | NetServer.`listen​(int port, String host)` | Start listening on the specified port and host, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `Future<NetServer>` | NetServer.`listen​(SocketAddress localAddress)` | Start listening on the specified local address, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default Future<Void>` | NetSocket.`sendFile​(String filename)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `default Future<Void>` | NetSocket.`sendFile​(String filename, long offset)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetSocket.`sendFile​(String filename, long offset, long length)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `default Future<Void>` | NetClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `default Future<Void>` | NetServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `default Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `default Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `default Future<Void>` | NetSocket.`upgradeToSsl()` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` with the default SSL options, without indicating a server name, without an upgrade message.
    `default Future<Void>` | NetSocket.`upgradeToSsl​(Buffer msg)` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` with the default SSL options and without indicating a server name.
    `default Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions)` | Upgrade channel to use SSL/TLS.
    `default Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, Buffer msg)` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` without indicating a server name
    `default Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName)` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` without an upgrade message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName, Buffer upgrade)` | Upgrade the channel to use SSL/TLS, in other words proceeds to the TLS handshake.
    `default Future<Void>` | NetSocket.`upgradeToSsl​(String serverName)` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` with the default SSL options and without an update message.
    `default Future<Void>` | NetSocket.`upgradeToSsl​(String serverName, Buffer msg)` | Like `NetSocket.upgradeToSsl(SSLOptions, String, Buffer)` with the default SSL options.
    `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.net.endpoint

    Methods in io.vertx.core.net.endpoint that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Endpoint>` | EndpointResolver.`resolveEndpoint​(Address address)` | Resolver an endpoint for the specified `address`

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

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

    Method parameters in io.vertx.core.shareddata with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <T> Future<T>` | SharedData.`withLocalLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLocalLock(String, Supplier)` but specifying a timeout.
    `default <T> Future<T>` | SharedData.`withLocalLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous local lock with the specified name.
    `default <T> Future<T>` | SharedData.`withLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLock(String, Supplier)` but specifying a timeout.
    `default <T> Future<T>` | SharedData.`withLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous lock with the specified name.

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

    Methods in io.vertx.core.spi.dns that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | AddressResolverProvider.`close()` |

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

    Methods in io.vertx.core.spi.endpoint that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<D>` | EndpointResolver.`resolve​(A address, EndpointBuilder<E,​S> builder)` | Resolve an address to the resolver state for this name.

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

    Methods in io.vertx.core.streams that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <R,​A> Future<R>` | ReadStream.`collect​(java.util.stream.Collector<T,​A,​R> collector)` | Apply a `collector` to this stream, the obtained result is returned as a future.
    `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)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | Pipe.`to​(WriteStream<T> dst)` | Start to pipe the elements to the destination `WriteStream`.
    `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 | Description
    --- | --- | ---
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, DB2ConnectOptions connectOptions)` | Create a connection to DB2 server with the given `connectOptions`.
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, String connectionUri)` | Like `DB2Connection.connect(Vertx, DB2ConnectOptions)` with options build from `connectionUri`.
    `Future<Void>` | DB2Connection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<Void>` | DB2Connection.`ping()` | Send a PING command to check if the server is alive.

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

    Method parameters in io.vertx.db2client.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | DB2Driver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.ext.auth.authentication that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<User>` | AuthenticationProvider.`authenticate​(Credentials 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 | Description
    --- | --- | ---
    `Future<Void>` | AuthorizationProvider.`getAuthorizations​(User user)` | Updates the user with the set of authorizations.

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

    Methods in io.vertx.ext.auth.mongo that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<String>` | MongoUserUtil.`createHashedUser​(String username, String hash)` | Insert a user into a database.
    `Future<String>` | MongoUserUtil.`createUser​(String username, String password)` | Insert a user into a database.
    `Future<String>` | MongoUserUtil.`createUserRolesAndPermissions​(String user, List<String> roles, List<String> permissions)` | Insert a user role into a database.

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

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

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

    Methods in io.vertx.ext.auth.oauth2.providers that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OAuth2Auth>` | AmazonCognitoAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | AppleIdAuth.`discover​(Vertx vertx, PubSecKeyOptions privateKey, 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>` | GoogleAuth.`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>` | KeycloakAuth.`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>` | SalesforceAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.

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

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

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

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

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

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

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

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

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

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

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

  - ### 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 | 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 | Description
    --- | --- | ---
    `Future<CheckResult>` | HealthChecks.`checkStatus()` | Invokes the registered procedures.
    `Future<CheckResult>` | HealthChecks.`checkStatus​(String name)` | Invokes the registered procedure with the given name and sub-procedures.
    `Future<JsonObject>` | HealthChecks.`invoke​(String name)` | Invokes the registered procedure with the given name and sub-procedures.

    Methods in io.vertx.ext.healthchecks with parameters of type Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `Future<Void>` | MailClient.`close()` | Close the MailClient
    `Future<MailResult>` | MailClient.`sendMail​(MailMessage email)` | send a single mail via MailClient

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

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

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

    Methods in io.vertx.ext.reactivestreams that return Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `Future<Void>` | ShellServer.`close()` | Close the shell server, this is an asynchronous close.
    `Future<Void>` | ShellServer.`listen()` | Start the shell service, this is an asynchronous start.
    `Future<Void>` | ShellService.`start()` | Start the shell service, this is an asynchronous start.
    `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 | Description
    --- | --- | ---
    `Future<Command>` | CommandRegistry.`registerCommand​(Command command)` | Register a command
    `Future<Command>` | CommandRegistry.`registerCommand​(Class<? extends AnnotatedCommand> command)` | Register a single command.
    `Future<List<Command>>` | CommandRegistry.`registerCommands​(List<Command> commands)` | Register a list of commands.
    `Future<Void>` | CommandRegistry.`unregisterCommand​(String commandName)` | Unregister a command.

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

    Methods in io.vertx.ext.shell.term that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | TermServer.`close()` | Close the server.
    `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 | 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>` | StompClient.`close()` | Closes the client.
    `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()` | Connects to the server using the host and port configured in the client's options.
    `Future<StompClientConnection>` | StompClient.`connect​(int port, String host)` | Connects to the server.
    `Future<Frame>` | StompClientConnection.`disconnect()` | Disconnects the client.
    `Future<Frame>` | StompClientConnection.`disconnect​(Frame frame)` | Disconnects the client.
    `Future<StompServer>` | StompServer.`listen()` | Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `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)` | Called when the client connects to a server requiring authentication.
    `Future<Frame>` | StompClientConnection.`send​(Frame frame)` | Sends the given 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<Frame>` | StompClientConnection.`send​(Map<String,​String> headers, Buffer body)` | Sends a `SEND` frame to the server.
    `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 | 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 | Description
    --- | --- | ---
    `Future<Void>` | FileUpload.`delete()` | Delete the uploaded file on the disk.
    `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.
    `Future<Void>` | UserContext.`impersonate()` | Impersonates a second identity.
    `Future<Void>` | UserContext.`impersonate​(String redirectUri)` | Impersonates a second identity.
    `default Future<Void>` | RoutingContext.`json​(Object json)` | Encode an Object to JSON and end the request.
    `Future<Void>` | UserContext.`logout()` | Logout can be called from any route handler which needs to terminate a login session.
    `Future<Void>` | UserContext.`logout​(String redirectUri)` | Logout can be called from any route handler which needs to terminate a login session.
    `default Future<Void>` | RoutingContext.`redirect​(String url)` | Perform a 302 redirect to `url`.
    `Future<Void>` | UserContext.`refresh()` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`refresh​(String redirectUri)` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`restore()` | Undo a previous call to a impersonation.
    `Future<Void>` | UserContext.`restore​(String redirectUri)` | Undo a previous call to an impersonation.

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

    Methods in io.vertx.ext.web.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<HttpResponse<T>>` | HttpRequest.`send()` | Send a request, the `handler` will receive the response as an `HttpResponse`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendBuffer​(Buffer body)` | Like `HttpRequest.send()` but with an HTTP request `body` buffer.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body, String charset)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJson​(Object body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJsonObject​(JsonObject body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendMultipartForm​(MultipartForm body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendStream​(ReadStream<Buffer> body)` | Like `HttpRequest.send()` but with an HTTP request `body` stream.
    `default Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

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

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

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

    Methods in io.vertx.ext.web.codec.spi that return Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `default Future<Buffer>` | TemplateEngine.`render​(JsonObject context, String templateFileName)` | Render the template.
    `Future<Buffer>` | TemplateEngine.`render​(Map<String,​Object> context, String templateFileName)` | Render the template.

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

    Methods in io.vertx.ext.web.handler that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Future<Void>` | SessionHandler.`flush​(RoutingContext ctx)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `Future<Void>` | SessionHandler.`flush​(RoutingContext ctx, boolean ignoreStatus)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `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 | 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.
    `APIKeyHandler` | APIKeyHandler.`tokenExtractor​(java.util.function.Function<String,​Future<String>> tokenExtractor)` | Transform from user's token format to the AuthenticationHandler's format.

  - ### 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 | Description
    --- | --- | ---
    `Future<Void>` | SockJSSocket.`end()` | Call `SockJSSocket.close()`.
    `Future<Void>` | SockJSSocket.`write​(Buffer data)` |
    `default Future<Void>` | SockJSSocket.`write​(String data)` | Write a `String` to the socket, encoded in UTF-8.

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

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

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

    Methods in io.vertx.ext.web.openapi.router that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<ValidatableRequest>` | RequestExtractor.`extractValidatableRequest​(RoutingContext routingContext, Operation operation)` | Extracts and transforms the parameters and the body of an incoming request into a `format` that can be validated by the `RequestValidator`.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(String callback, java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the `OAuth2AuthHandler` to be used when creating the router.
    `default Future<RouterBuilder>` | Security.`openIdConnectHandler​(java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the `OAuth2AuthHandler` to be used when creating the router.

    Method parameters in io.vertx.ext.web.openapi.router with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(String callback, java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the `OAuth2AuthHandler` to be used when creating the router.
    `default Future<RouterBuilder>` | Security.`openIdConnectHandler​(java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the `OAuth2AuthHandler` to be used when creating the router.

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

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

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

    Methods in io.vertx.grpc.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcClient.`close()` | Close this client.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request()` | Like `GrpcClient.request(Address)` with the default remote server.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request​(Address server)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(Address server, ServiceMethod<Resp,​Req> method)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(ServiceMethod<Resp,​Req> method)` | Like `GrpcClient.request(Address, ServiceMethod)` with the default remote server.
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`response()` |
    `default Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(ReadStream<Req> body)` |
    `default Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(Req item)` |

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

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

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

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

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

    Methods in io.vertx.grpcio.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <Req,​Resp,​T> Future<T>` | GrpcIoClient.`call​(MethodDescriptor<Req,​Resp> service, Handler<GrpcClientRequest<Req,​Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,​Resp>,​Future<T>> resultFn)` | Like `GrpcIoClient.call(Address, MethodDescriptor, Handler, Function)` with the default remote server.
    `default <Req,​Resp,​T> Future<T>` | GrpcIoClient.`call​(Address server, MethodDescriptor<Req,​Resp> service, Handler<GrpcClientRequest<Req,​Resp>> requestHandler, java.util.function.Function<GrpcClientResponse<Req,​Resp>,​Future<T>> resultFn)` | Call the `service` gRPC service hosted by `server`.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcIoClient.`request​(MethodDescriptor<Req,​Resp> service)` | Like `GrpcIoClient.request(Address, MethodDescriptor)` with the default remote server.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcIoClient.`request​(Address server, MethodDescriptor<Req,​Resp> service)` | Connect to the remote `server` and create a request for given `method` of a hosted gRPC service.

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

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

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

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

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

    Methods in io.vertx.jdbcclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Integer>` | JDBCConnection.`getTransactionIsolation()` |
    `Future<Void>` | JDBCConnection.`setTransactionIsolation​(int isolationLevel)` |

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

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

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

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

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

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

    Methods in io.vertx.kafka.client.consumer that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | KafkaConsumer.`assign​(TopicPartition topicPartition)` | Manually assign a partition to this consumer.
    `Future<Void>` | KafkaConsumer.`assign​(Set<TopicPartition> topicPartitions)` | Manually assign a list of partition to this consumer.
    `Future<Void>` | KafkaReadStream.`assign​(Set<org.apache.kafka.common.TopicPartition> partitions)` | Manually assign a set of partitions to this consumer.
    `Future<Set<TopicPartition>>` | KafkaConsumer.`assignment()` | Get the set of partitions currently assigned to this consumer.
    `Future<Set<org.apache.kafka.common.TopicPartition>>` | KafkaReadStream.`assignment()` | Get the set of partitions currently assigned to this consumer.
    `Future<Long>` | KafkaConsumer.`beginningOffsets​(TopicPartition topicPartition)` | Get the first offset for the given partitions.
    `Future<Map<TopicPartition,​Long>>` | KafkaConsumer.`beginningOffsets​(Set<TopicPartition> topicPartitions)` | Get the first offset for the given partitions.
    `Future<Map<org.apache.kafka.common.TopicPartition,​Long>>` | KafkaReadStream.`beginningOffsets​(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` | Get the first offset for the given partitions.
    `Future<Long>` | KafkaReadStream.`beginningOffsets​(org.apache.kafka.common.TopicPartition topicPartition)` | Get the first offset for the given partition.
    `Future<Void>` | KafkaConsumer.`close()` | Close the consumer
    `Future<Void>` | KafkaReadStream.`close()` | Close the stream
    `Future<Void>` | KafkaConsumer.`commit()` | Commit current offsets for all the subscribed list of topics and partition.
    `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<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<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<OffsetAndMetadata>` | KafkaConsumer.`committed​(TopicPartition topicPartition)` | Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `Future<org.apache.kafka.clients.consumer.OffsetAndMetadata>` | KafkaReadStream.`committed​(org.apache.kafka.common.TopicPartition topicPartition)` | Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `Future<Long>` | KafkaConsumer.`endOffsets​(TopicPartition topicPartition)` | Get the last offset for the given partition.
    `Future<Map<TopicPartition,​Long>>` | KafkaConsumer.`endOffsets​(Set<TopicPartition> topicPartitions)` | Get the last offset for the given partitions.
    `Future<Map<org.apache.kafka.common.TopicPartition,​Long>>` | KafkaReadStream.`endOffsets​(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` | Get the last offset for the given partitions.
    `Future<Long>` | KafkaReadStream.`endOffsets​(org.apache.kafka.common.TopicPartition topicPartition)` | Get the last offset for the given partition.
    `Future<Map<String,​List<PartitionInfo>>>` | KafkaConsumer.`listTopics()` | Get metadata about partitions for all topics that the user is authorized to view.
    `Future<Map<String,​List<org.apache.kafka.common.PartitionInfo>>>` | KafkaReadStream.`listTopics()` | Get metadata about partitions for all topics that the user is authorized to view.
    `Future<OffsetAndTimestamp>` | KafkaConsumer.`offsetsForTimes​(TopicPartition topicPartition, Long timestamp)` | Look up the offset for the given partition by timestamp.
    `Future<Map<TopicPartition,​OffsetAndTimestamp>>` | KafkaConsumer.`offsetsForTimes​(Map<TopicPartition,​Long> topicPartitionTimestamps)` | Look up the offsets for the given partitions by timestamp.
    `Future<Map<org.apache.kafka.common.TopicPartition,​org.apache.kafka.clients.consumer.OffsetAndTimestamp>>` | KafkaReadStream.`offsetsForTimes​(Map<org.apache.kafka.common.TopicPartition,​Long> topicPartitionTimestamps)` | Look up the offsets for the given partitions by timestamp.
    `Future<org.apache.kafka.clients.consumer.OffsetAndTimestamp>` | KafkaReadStream.`offsetsForTimes​(org.apache.kafka.common.TopicPartition topicPartition, long timestamp)` | * Look up the offset for the given partition by timestamp.
    `Future<List<PartitionInfo>>` | KafkaConsumer.`partitionsFor​(String topic)` | Get metadata about the partitions for a given topic.
    `Future<List<org.apache.kafka.common.PartitionInfo>>` | KafkaReadStream.`partitionsFor​(String topic)` | Get metadata about the partitions for a given topic.
    `Future<Void>` | KafkaConsumer.`pause​(TopicPartition topicPartition)` | Suspend fetching from the requested partition.
    `Future<Void>` | KafkaConsumer.`pause​(Set<TopicPartition> topicPartitions)` | Suspend fetching from the requested partitions.
    `Future<Void>` | KafkaReadStream.`pause​(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` | Suspend fetching from the requested partitions.
    `Future<Set<TopicPartition>>` | KafkaConsumer.`paused()` | Get the set of partitions that were previously paused by a call to pause(Set).
    `Future<Set<org.apache.kafka.common.TopicPartition>>` | KafkaReadStream.`paused()` | Get the set of partitions that were previously paused by a call to `KafkaReadStream.pause(Set)`.
    `Future<KafkaConsumerRecords<K,​V>>` | KafkaConsumer.`poll​(java.time.Duration timeout)` | Executes a poll for getting messages from Kafka.
    `Future<org.apache.kafka.clients.consumer.ConsumerRecords<K,​V>>` | KafkaReadStream.`poll​(java.time.Duration timeout)` | Executes a poll for getting messages from Kafka.
    `Future<Long>` | KafkaConsumer.`position​(TopicPartition partition)` | Get the offset of the next record that will be fetched (if a record with that offset exists).
    `Future<Long>` | KafkaReadStream.`position​(org.apache.kafka.common.TopicPartition partition)` | Get the offset of the next record that will be fetched (if a record with that offset exists).
    `Future<Void>` | KafkaConsumer.`resume​(TopicPartition topicPartition)` | Resume specified partition which have been paused with pause.
    `Future<Void>` | KafkaConsumer.`resume​(Set<TopicPartition> topicPartitions)` | Resume specified partitions which have been paused with pause.
    `Future<Void>` | KafkaReadStream.`resume​(Set<org.apache.kafka.common.TopicPartition> topicPartitions)` | Resume specified partitions which have been paused with pause.
    `Future<Void>` | KafkaConsumer.`seek​(TopicPartition topicPartition, long offset)` | Overrides the fetch offsets that the consumer will use on the next poll.
    `Future<Void>` | KafkaConsumer.`seek​(TopicPartition topicPartition, OffsetAndMetadata offsetAndMetadata)` | Overrides the fetch offsets that the consumer will use on the next poll.
    `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>` | KafkaReadStream.`seek​(org.apache.kafka.common.TopicPartition topicPartition, org.apache.kafka.clients.consumer.OffsetAndMetadata offsetAndMetadata)` | Overrides the fetch offsets that the consumer will use on the next poll.
    `Future<Void>` | KafkaConsumer.`seekToBeginning​(TopicPartition topicPartition)` | Seek to the first offset for each of the given partition.
    `Future<Void>` | KafkaConsumer.`seekToBeginning​(Set<TopicPartition> topicPartitions)` | Seek to the first offset for each of the given partitions.
    `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.`seekToEnd​(TopicPartition topicPartition)` | Seek to the last offset for each of the given partition.
    `Future<Void>` | KafkaConsumer.`seekToEnd​(Set<TopicPartition> topicPartitions)` | Seek to the last offset for each of the given partitions.
    `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.`subscribe​(String topic)` | Subscribe to the given topic 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>` | KafkaConsumer.`subscribe​(Set<String> topics)` | Subscribe to the given list of topics to get dynamically assigned partitions.
    `Future<Void>` | KafkaReadStream.`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<Set<String>>` | KafkaConsumer.`subscription()` | Get the current subscription.
    `Future<Set<String>>` | KafkaReadStream.`subscription()` | Get the current subscription.
    `Future<Void>` | KafkaConsumer.`unsubscribe()` | Unsubscribe from topics currently subscribed with subscribe.
    `Future<Void>` | KafkaReadStream.`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 | Description
    --- | --- | ---
    `Future<Void>` | KafkaProducer.`abortTransaction()` | Aborts the ongoing transaction.
    `Future<Void>` | KafkaWriteStream.`abortTransaction()` | Aborts the ongoing transaction.
    `Future<Void>` | KafkaProducer.`beginTransaction()` | Starts a new kafka transaction.
    `Future<Void>` | KafkaWriteStream.`beginTransaction()` | Starts a new kafka transaction.
    `Future<Void>` | KafkaProducer.`close()` | Close the producer
    `Future<Void>` | KafkaProducer.`close​(long timeout)` | Close the producer
    `Future<Void>` | KafkaWriteStream.`close()` | Close the stream
    `Future<Void>` | KafkaWriteStream.`close​(long timeout)` | Close the stream
    `Future<Void>` | KafkaProducer.`commitTransaction()` | Commits the ongoing transaction.
    `Future<Void>` | KafkaWriteStream.`commitTransaction()` | Commits the ongoing transaction.
    `Future<Void>` | KafkaProducer.`flush()` | Invoking this method makes all buffered records immediately available to write
    `Future<Void>` | KafkaWriteStream.`flush()` | Invoking this method makes all buffered records immediately available to write
    `Future<Void>` | KafkaProducer.`initTransactions()` | Initializes the underlying kafka transactional producer.
    `Future<Void>` | KafkaWriteStream.`initTransactions()` | Initializes the underlying kafka transactional producer.
    `Future<List<PartitionInfo>>` | KafkaProducer.`partitionsFor​(String topic)` | Get the partition metadata for the give topic.
    `Future<List<org.apache.kafka.common.PartitionInfo>>` | KafkaWriteStream.`partitionsFor​(String topic)` | Get the partition metadata for the give topic.
    `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 | Description
    --- | --- | ---
    `Future<Void>` | MqttClient.`authenticationExchange​(MqttAuthenticationExchangeMessage message)` | It is used for Enhanced Authentication and is able to carry an authentication method and authentication data.
    `Future<Void>` | MqttServer.`close()` | Close the server.
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host)` | Connects to an MQTT server calling connectHandler after connection
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host, String serverName)` | Connects to an MQTT server calling connectHandler after connection
    `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, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT server
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT client
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttClient.`subscribe​(String topic, int qos)` | Subscribes to the topic with a specified QoS level
    `Future<Integer>` | MqttClient.`subscribe​(Map<String,​Integer> topics)` | Subscribes to the topics with related QoS levels
    `Future<Integer>` | MqttClient.`unsubscribe​(String topic)` | Unsubscribe from receiving messages on given topic
    `Future<Integer>` | MqttClient.`unsubscribe​(List<String> topics)` | Unsubscribe from receiving messages on given list of topic

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

    Methods in io.vertx.mssqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, MSSQLConnectOptions connectOptions)` | Create a connection to SQL Server with the given `connectOptions`.
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MSSQLConnection.connect(Vertx, MSSQLConnectOptions)` with options built from `connectionUri`.

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

    Method parameters in io.vertx.mssqlclient.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | MSSQLDriver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<MSSQLConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.mysqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MySQLConnection.`changeUser​(MySQLAuthOptions options)` | Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, MySQLConnectOptions connectOptions)` | Create a connection to MySQL server with the given `connectOptions`.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MySQLConnection.connect(Vertx, MySQLConnectOptions)` with options built from `connectionUri`.
    `Future<Void>` | MySQLConnection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<String>` | MySQLConnection.`getInternalStatistics()` | Send a STATISTICS command to get a human readable string of the server internal status.
    `Future<Void>` | MySQLConnection.`ping()` | Send a PING command to check if the server is alive.
    `Future<Void>` | MySQLConnection.`resetConnection()` | Send a RESET_CONNECTION command to reset the session state.
    `Future<Void>` | MySQLConnection.`setOption​(MySQLSetOption option)` | Send a SET_OPTION command to set options for the current connection.
    `Future<Void>` | MySQLConnection.`specifySchema​(String schemaName)` | Send a INIT_DB command to change the default schema of the connection.

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

    Method parameters in io.vertx.mysqlclient.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | MySQLDriver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<MySQLConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

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

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

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

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

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

    Methods in io.vertx.oracleclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, OracleConnectOptions connectOptions)` | Create a connection to Oracle with the given `connectOptions`.
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, String connectionUri)` | Like `OracleConnection.connect(Vertx, OracleConnectOptions)` with options built from `connectionUri`.

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

    Method parameters in io.vertx.oracleclient.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | OracleDriver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<OracleConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.pgclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgConnection.`cancelRequest()` | Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx)` | Like `PgConnection.connect(Vertx, PgConnectOptions)` with options build from the environment variables.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, PgConnectOptions options)` | Connects to the database and returns the connection if that succeeds.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, String connectionUri)` | Like `PgConnection.connect(Vertx, PgConnectOptions)` with options build from `connectionUri`.

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

    Methods in io.vertx.pgclient.pubsub that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgSubscriber.`close()` | Close the subscriber, the retry policy will not be invoked.
    `Future<Void>` | PgSubscriber.`connect()` | Connect the subscriber to Postgres.

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

    Method parameters in io.vertx.pgclient.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | PgDriver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

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

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

    Methods in io.vertx.reactivex that return Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `Future<Void>` | AmqpClient.`close()` | Closes the client.
    `Future<Void>` | AmqpConnection.`close()` | Closes the AMQP connection, i.e.
    `Future<Void>` | AmqpReceiver.`close()` | Closes the receiver.
    `Future<Void>` | AmqpSender.`close()` | Closes the sender.
    `Future<Void>` | AmqpConnection.`closeFuture()` |
    `Future<AmqpConnection>` | AmqpClient.`connect()` | Connects to the AMQP broker or router.
    `Future<AmqpSender>` | AmqpConnection.`createAnonymousSender()` | Creates an anonymous sender.
    `Future<AmqpReceiver>` | AmqpConnection.`createDynamicReceiver()` | Creates a dynamic receiver.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<Void>` | AmqpSender.`end()` | Ends the stream.
    `Future<Void>` | AmqpSender.`end​(AmqpMessage data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | AmqpReceiver.`pipeTo​(WriteStream<AmqpMessage> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | AmqpSender.`sendWithAck​(AmqpMessage message)` | Sends an AMQP message and waits for an acknowledgement.
    `Future<Void>` | AmqpSender.`write​(AmqpMessage data)` | Write some data to the stream.

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

    Methods in io.vertx.reactivex.cassandra that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | ResultSet.`all()` | The method should not be used concurrently with others like `ResultSet.fetchNextPage()` or `ResultSet.one()`.
    `Future<Void>` | CassandraClient.`close()` | Closes this client.
    `Future<ResultSet>` | CassandraClient.`execute​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the statement and provide a handler for consuming results.
    `Future<ResultSet>` | CassandraClient.`execute​(String query)` | Execute the query and provide a handler for consuming results.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the query and provide a handler for consuming results.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(String query)` | Execute the query and provide a handler for consuming results.
    `Future<ResultSet>` | ResultSet.`fetchNextPage()` |
    `Future<com.datastax.oss.driver.api.core.metadata.Metadata>` | CassandraClient.`metadata()` | Get for the session.
    `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)` | Prepares the provided a .
    `Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>` | CassandraClient.`prepare​(String query)` | Prepares the provided query string.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Executes the given SQL statement which returns the results of the query as a read stream.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(String sql)` | Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

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

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

    Methods in io.vertx.reactivex.circuitbreaker with parameters of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | FailurePolicy.`test​(Future<T> future)` | Invoked by the `CircuitBreaker` when an operation completes.

    Method parameters in io.vertx.reactivex.circuitbreaker with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(java.util.function.Supplier<Future<T>> command, java.util.function.Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | CircuitBreaker.`rxExecute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback​(java.util.function.Supplier<Future<T>> command, java.util.function.Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.

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

    Methods in io.vertx.reactivex.config that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | ConfigRetriever.`close()` | Closes the retriever.
    `Future<JsonObject>` | ConfigRetriever.`getConfig()` | Reads the configuration from the different and computes the final configuration.

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

    Methods in io.vertx.reactivex.core that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Vertx>` | VertxBuilder.`buildClustered()` | Creates a clustered instance.
    `Future<Void>` | Vertx.`close()` | Stop the Vertx instance and release any resources held by it.
    `Future<Void>` | WorkerExecutor.`close()` | Close the executor.
    `static Future<Vertx>` | Vertx.`clusteredVertx​(VertxOptions options)` | Creates a clustered instance using the specified options.
    `Future<String>` | Vertx.`deployVerticle​(Deployable verticle)` | Deploy a verticle instance that you have created yourself.
    `Future<String>` | Vertx.`deployVerticle​(Deployable verticle, DeploymentOptions options)` | Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `Future<String>` | Vertx.`deployVerticle​(String name)` | Deploy a verticle instance given a name.
    `Future<String>` | Vertx.`deployVerticle​(String name, DeploymentOptions options)` | Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `<T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler)` | Invoke `Context.executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
    `<T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `<T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `Vertx.executeBlocking(java.util.concurrent.Callable<T>, boolean)` called with ordered = true.
    `<T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `<T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `WorkerExecutor.executeBlocking(java.util.concurrent.Callable<T>, boolean)` called with ordered = true.
    `<T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `Future<T>` | Promise.`future()` |
    `Future<Void>` | Vertx.`undeploy​(String deploymentID)` | Undeploy a verticle deployment.

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

    Methods in io.vertx.reactivex.core.datagram that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String sourceToBlock)` | Block the given address for the given multicast address and notifies the once the operation completes.
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String networkInterface, String sourceToBlock)` | Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `Future<Void>` | DatagramSocket.`close()` | Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `Future<DatagramSocket>` | DatagramSocket.`listen​(int port, String host)` | Start listening on the given port and host.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress)` | Joins a multicast group and listens for packets send to it.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Joins a multicast group and listens for packets send to it on the given network interface.
    `Future<Void>` | DatagramSocket.`send​(Buffer packet, int port, String host)` | Write the given `Buffer` to the `SocketAddress`.
    `Future<Void>` | DatagramSocket.`send​(String str, int port, String host)` | Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `Future<Void>` | DatagramSocket.`send​(String str, String enc, int port, String host)` | Write the given `String` to the `SocketAddress` using the given encoding.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress)` | Leaves a multicast group and stops listening for packets send to it.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Leaves a multicast group and stops listening for packets send to it on the given network interface.

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

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

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

    Methods in io.vertx.reactivex.core.eventbus that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MessageProducer.`close()` | Closes the producer, this method should be called when the message producer is not used anymore.
    `Future<Void>` | MessageConsumer.`completion()` |
    `Future<Void>` | MessageConsumer.`pipeTo​(WriteStream<Message<T>> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `<R> Future<Message<R>>` | Message.`replyAndRequest​(Object message)` | Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<R> Future<Message<R>>` | Message.`replyAndRequest​(Object message, DeliveryOptions options)` | Like `Message.replyAndRequest(java.lang.Object)` but specifying `options` that can be used to configure the delivery.
    `<T> Future<Message<T>>` | EventBus.`request​(String address, Object message)` | Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> Future<Message<T>>` | EventBus.`request​(String address, Object message, DeliveryOptions options)` | Like `EventBus.request(java.lang.String, java.lang.Object)` but specifying `options` that can be used to configure the delivery.
    `Future<Void>` | MessageConsumer.`unregister()` | Unregisters the handler which created this registration
    `Future<Void>` | MessageProducer.`write​(T body)` | Write a message to the event-bus, either sending or publishing.

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

    Methods in io.vertx.reactivex.core.file that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | FileSystem.`chmod​(String path, String perms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chmodRecursive​(String path, String perms, String dirPerms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chown​(String path, String user, String group)` | Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `Future<Void>` | AsyncFile.`close()` | Close the file.
    `Future<Void>` | FileSystem.`copy​(String from, String to)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copy​(String from, String to, CopyOptions options)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copyRecursive​(String from, String to, boolean recursive)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path)` | Creates an empty file with the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path, String perms)` | Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix, String perms)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String dir, String prefix, String perms)` | Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix)` | Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String dir, String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<Void>` | FileSystem.`delete​(String path)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`deleteRecursive​(String path, boolean recursive)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Void>` | AsyncFile.`end()` | Ends the stream.
    `Future<Void>` | AsyncFile.`end​(Buffer data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Boolean>` | FileSystem.`exists​(String path)` | Determines whether the file as specified by the path `path` exists, asynchronously.
    `Future<Void>` | AsyncFile.`flush()` | Flush any writes made to this file to underlying persistent storage.
    `Future<FileSystemProps>` | FileSystem.`fsProps​(String path)` | Returns properties of the file-system being used by the specified `path`, asynchronously.
    `Future<Boolean>` | AsyncFileLock.`isValid()` | A lock remains valid until it is released or the file corresponding `AsyncFile` is closed.
    `Future<Void>` | FileSystem.`link​(String link, String existing)` | Create a hard link on the file system from `link` to `existing`, asynchronously.
    `Future<AsyncFileLock>` | AsyncFile.`lock()` | Acquire a non-shared lock on the entire file.
    `Future<AsyncFileLock>` | AsyncFile.`lock​(long position, long size, boolean shared)` | Acquire a lock on a portion of this file.
    `Future<FileProps>` | FileSystem.`lprops​(String path)` | Obtain properties for the link represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path, String perms)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path, String perms)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to, CopyOptions options)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<AsyncFile>` | FileSystem.`open​(String path, OpenOptions options)` | Open the file represented by `path`, asynchronously.
    `Future<Void>` | AsyncFile.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<FileProps>` | FileSystem.`props​(String path)` | Obtain properties for the file represented by `path`, asynchronously.
    `Future<Buffer>` | AsyncFile.`read​(Buffer buffer, int offset, long position, int length)` | Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path, String filter)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<Buffer>` | FileSystem.`readFile​(String path)` | Reads the entire file as represented by the path `path` as a , asynchronously.
    `Future<String>` | FileSystem.`readSymlink​(String link)` | Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `Future<Void>` | AsyncFileLock.`release()` | Releases this lock;
    `Future<Long>` | AsyncFile.`size()` |
    `Future<Void>` | FileSystem.`symlink​(String link, String existing)` | Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `Future<Void>` | FileSystem.`truncate​(String path, long len)` | Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `Future<Void>` | FileSystem.`unlink​(String link)` | Unlinks the link on the file system represented by the path `link`, asynchronously.
    `<T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.
    `Future<Void>` | AsyncFile.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | AsyncFile.`write​(Buffer buffer, long position)` | Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `Future<Void>` | FileSystem.`writeFile​(String path, Buffer data)` | Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

    Method parameters in io.vertx.reactivex.core.file with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Single<T>` | AsyncFile.`rxWithLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Single<T>` | AsyncFile.`rxWithLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.
    `<T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.

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

    Methods in io.vertx.reactivex.core.http that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<ServerWebSocket>` | ServerWebSocketHandshake.`accept()` | Accept the WebSocket and terminate the WebSocket handshake.
    `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>` | ClientWebSocket.`close()` | Close the WebSocket sending the default close frame.
    `Future<Void>` | ClientWebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | ClientWebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `Future<Void>` | HttpClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpClientAgent.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpClientConnection.`close()` |
    `Future<Void>` | HttpConnection.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpServer.`close()` | Close the server.
    `Future<Void>` | ServerWebSocket.`close()` | The WebSocket handshake will be accepted when it hasn't yet been settled or when an asynchronous handshake is in progress.
    `Future<Void>` | ServerWebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | ServerWebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `Future<Void>` | WebSocket.`close()` | Close the WebSocket sending the default close frame.
    `Future<Void>` | WebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | WebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `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<Void>` | WebSocketClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<WebSocket>` | ClientWebSocket.`connect​(int port, String host, String requestURI)` | Connect this WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | ClientWebSocket.`connect​(WebSocketConnectOptions options)` | Connect this WebSocket with the specified options.
    `Future<WebSocket>` | ClientWebSocket.`connect​(String requestURI)` | Connect this WebSocket at the relative request URI using the default host and port.
    `Future<WebSocket>` | ClientWebSocket.`connect​(String host, String requestURI)` | Connect this WebSocket to the host and relative request URI and default port.
    `Future<HttpClientConnection>` | HttpClientAgent.`connect​(HttpConnectOptions options)` | Connect to a remote HTTP server with the specific `options`, the connection is un-pooled and the management of the connection is left to the user.
    `Future<HttpClientResponse>` | HttpClientRequest.`connect()` | Create an HTTP tunnel to the server.
    `Future<WebSocket>` | WebSocketClient.`connect​(int port, String host, String requestURI)` | Connect a WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | WebSocketClient.`connect​(WebSocketConnectOptions options)` | Connect a WebSocket with the specified options.
    `Future<WebSocket>` | WebSocketClient.`connect​(String requestURI)` | Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `Future<WebSocket>` | WebSocketClient.`connect​(String host, String requestURI)` | Connect a WebSocket to the default client port and specified host and relative request URI.
    `Future<Void>` | ClientWebSocket.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | ClientWebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | HttpClientRequest.`end()` | Ends the request.
    `Future<Void>` | HttpClientRequest.`end​(Buffer chunk)` | Same as `HttpClientRequest.end(java.lang.String)` but writes some data to the request body before ending.
    `Future<Void>` | HttpClientRequest.`end​(String chunk)` | Same as `HttpClientRequest.end(java.lang.String)` but writes a String in UTF-8 encoding
    `Future<Void>` | HttpClientRequest.`end​(String chunk, String enc)` | Same as `HttpClientRequest.end(java.lang.String)` but writes a String with the specified encoding
    `Future<Void>` | HttpClientResponse.`end()` | Returns a future signaling when the response has been fully received successfully or failed.
    `Future<Void>` | HttpServerRequest.`end()` | Returns a future signaling when the request has been fully received successfully or failed.
    `Future<Void>` | HttpServerResponse.`end()` | Ends the response.
    `Future<Void>` | HttpServerResponse.`end​(Buffer chunk)` | Same as `HttpServerResponse.end(java.lang.String)` but writes some data to the response body before ending.
    `Future<Void>` | HttpServerResponse.`end​(String chunk)` | Same as `HttpServerResponse.end(java.lang.String)` but writes a String in UTF-8 encoding before ending the response.
    `Future<Void>` | HttpServerResponse.`end​(String chunk, String enc)` | Same as `HttpServerResponse.end(java.lang.String)` but writes a String with the specified encoding before ending the response.
    `Future<Void>` | ServerWebSocket.`end()` | Calls `ServerWebSocket.close(short)`
    `Future<Void>` | ServerWebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | WebSocket.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | WebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | WebSocketBase.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | WebSocketBase.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<HttpServer>` | HttpServer.`listen()` | Tell the server to start listening.
    `Future<HttpServer>` | HttpServer.`listen​(int port)` | Like `HttpServer.listen()` 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)` | Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `Future<Buffer>` | HttpConnection.`ping​(Buffer data)` | Send a frame to the remote endpoint.
    `Future<Void>` | ClientWebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpClientResponse.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpServerFileUpload.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpServerRequest.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | ServerWebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | WebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | WebSocketBase.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, HostAndPort authority, String path, MultiMap headers)` | Push a response to the client.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path, MultiMap headers)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with no headers.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path, MultiMap headers)` | Deprecated.
    `Future<Void>` | ServerWebSocketHandshake.`reject()` | Reject the WebSocket.
    `Future<Void>` | ServerWebSocketHandshake.`reject​(int status)` | Like `ServerWebSocketHandshake.reject()` but with a `status`.
    `Future<HttpClientRequest>` | HttpClient.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClient.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientRequest>` | HttpClientAgent.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientRequest>` | HttpClientConnection.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientResponse>` | HttpClientRequest.`response()` |
    `Future<HttpClientResponse>` | HttpClientRequest.`send()` | Send the request with an empty body.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(Flowable<Buffer> body)` | Send the request with a stream `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(Buffer body)` | Send the request with a buffer `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(String body)` | Send the request with a string `body`.
    `Future<Void>` | HttpServerResponse.`send()` | Send the request with an empty body.
    `Future<Void>` | HttpServerResponse.`send​(Flowable<Buffer> body)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`send​(Buffer body)` | Send the request with a buffer `body`.
    `Future<Void>` | HttpServerResponse.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`send​(String body)` | Send the request with a string `body`.
    `Future<Void>` | HttpServerResponse.`sendFile​(String filename)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`sendFile​(String filename, long offset)` | Same as `HttpServerResponse.sendFile(java.lang.String)` 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(java.lang.String)` is called on the request or any data is written to it.
    `Future<Void>` | ClientWebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | ClientWebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | HttpClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpClientAgent.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpClientAgent.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpClientConnection.`shutdown()` |
    `Future<Void>` | HttpClientConnection.`shutdown​(long timeout, TimeUnit unit)` |
    `Future<Void>` | HttpConnection.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpConnection.`shutdown​(long timeout, TimeUnit unit)` | Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `Future<Void>` | HttpServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `Future<Void>` | ServerWebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | ServerWebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | WebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocketBase.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | WebSocketBase.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocketClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | WebSocketClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpServerFileUpload.`streamToFileSystem​(String filename)` | Stream the content of this upload to the given file on storage.
    `Future<NetSocket>` | HttpServerRequest.`toNetSocket()` | Establish a TCP tunnel with the client.
    `Future<ServerWebSocket>` | HttpServerRequest.`toWebSocket()` | Upgrade the connection of the current request to a WebSocket.
    `Future<Void>` | HttpConnection.`updateSettings​(Http2Settings settings)` | Send to the remote endpoint an update of this endpoint settings
    `Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | ClientWebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpClientRequest.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpClientRequest.`write​(String chunk)` | Write a `String` to the request body, encoded as UTF-8.
    `Future<Void>` | HttpClientRequest.`write​(String chunk, String enc)` | Write a `String` to the request body, encoded using the encoding `enc`.
    `Future<Void>` | HttpServerResponse.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpServerResponse.`write​(String chunk)` | Write a `String` to the response body, encoded in UTF-8.
    `Future<Void>` | HttpServerResponse.`write​(String chunk, String enc)` | Write a `String` to the response body, encoded using the encoding `enc`.
    `Future<Void>` | ServerWebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | WebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | WebSocketBase.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | ClientWebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | ServerWebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | WebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | WebSocketBase.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | HttpServerResponse.`writeContinue()` | Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
    `Future<Void>` | HttpClientRequest.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
    `Future<Void>` | HttpClientRequest.`writeCustomFrame​(HttpFrame frame)` | Like `HttpClientRequest.writeCustomFrame(int, int, io.vertx.core.buffer.Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
    `Future<Void>` | HttpServerResponse.`writeCustomFrame​(HttpFrame frame)` | Like `HttpServerResponse.writeCustomFrame(int, int, io.vertx.core.buffer.Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeEarlyHints​(MultiMap headers)` | Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
    `Future<Void>` | ClientWebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | ClientWebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | ClientWebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | WebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | WebSocketBase.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | ClientWebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | ServerWebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | WebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | WebSocketBase.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | ClientWebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | ServerWebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | WebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | WebSocketBase.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | ClientWebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | ServerWebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | WebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | WebSocketBase.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.

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

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

    Methods in io.vertx.reactivex.core.net that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | NetClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | NetServer.`close()` | Close the server.
    `Future<Void>` | NetSocket.`close()` | Close the socket
    `Future<NetSocket>` | NetClient.`connect​(int port, String host)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(int port, String host, String serverName)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(ConnectOptions connectOptions)` | Open a connection to a server at the specific `connectOptions`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress, String serverName)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<Void>` | NetSocket.`end()` | Calls `NetSocket.close()`
    `Future<Void>` | NetSocket.`end​(Buffer data)` | Same as `NetSocket.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `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.
    `Future<Void>` | NetSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `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.
    `Future<Void>` | NetSocket.`sendFile​(String filename, long offset)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetSocket.`sendFile​(String filename, long offset, long length)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | NetServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | NetSocket.`upgradeToSsl()` | Like `NetSocket.upgradeToSsl()` with the default SSL options, without indicating a server name, without an upgrade message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(Buffer msg)` | Like `NetSocket.upgradeToSsl()` with the default SSL options and without indicating a server name.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions)` | Upgrade channel to use SSL/TLS.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, Buffer msg)` | Like `NetSocket.upgradeToSsl()` without indicating a server name
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName)` | Like `NetSocket.upgradeToSsl()` without an upgrade message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName, Buffer upgrade)` | Upgrade the channel to use SSL/TLS, in other words proceeds to the TLS handshake.
    `Future<Void>` | NetSocket.`upgradeToSsl​(String serverName)` | Like `NetSocket.upgradeToSsl()` with the default SSL options and without an update message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(String serverName, Buffer msg)` | Like `NetSocket.upgradeToSsl()` with the default SSL options.
    `Future<Void>` | NetSocket.`write​(Buffer data)` | Write some data to the stream.
    `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.reactivex.core.net.endpoint

    Methods in io.vertx.reactivex.core.net.endpoint that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Endpoint>` | EndpointResolver.`resolveEndpoint​(Address address)` | Resolver an endpoint for the specified `address`

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

    Methods in io.vertx.reactivex.core.parsetools that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | JsonParser.`pipeTo​(WriteStream<JsonEvent> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | RecordParser.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

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

    Method parameters in io.vertx.reactivex.core.shareddata with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Single<T>` | SharedData.`rxWithLocalLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLocalLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Single<T>` | SharedData.`rxWithLocalLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous local lock with the specified name.
    `<T> Single<T>` | SharedData.`rxWithLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Single<T>` | SharedData.`rxWithLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous lock with the specified name.
    `<T> Future<T>` | SharedData.`withLocalLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLocalLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Future<T>` | SharedData.`withLocalLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous local lock with the specified name.
    `<T> Future<T>` | SharedData.`withLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Future<T>` | SharedData.`withLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous lock with the specified name.

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

    Methods in io.vertx.reactivex.core.streams that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | WriteStream.`end()` | Ends the stream.
    `Future<Void>` | WriteStream.`end​(T data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | ReadStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | Pipe.`to​(WriteStream<T> dst)` | Start to pipe the elements to the destination `WriteStream`.
    `Future<Void>` | WriteStream.`write​(T data)` | Write some data to the stream.

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

    Methods in io.vertx.reactivex.db2client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, DB2ConnectOptions connectOptions)` | Create a connection to DB2 server with the given `connectOptions`.
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, String connectionUri)` | Like `DB2Connection.connect(io.vertx.reactivex.core.Vertx, io.vertx.db2client.DB2ConnectOptions)` with options build from `connectionUri`.
    `Future<Void>` | DB2Connection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<Void>` | DB2Connection.`ping()` | Send a PING command to check if the server is alive.

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

    Methods in io.vertx.reactivex.ext.auth.authentication that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<User>` | AuthenticationProvider.`authenticate​(Credentials credentials)` | Authenticate a user.

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

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

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

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

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

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

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

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

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

    Methods in io.vertx.reactivex.ext.auth.oauth2.providers that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OAuth2Auth>` | AmazonCognitoAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | AppleIdAuth.`discover​(Vertx vertx, PubSecKeyOptions privateKey, 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>` | GoogleAuth.`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>` | KeycloakAuth.`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>` | SalesforceAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.

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

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

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

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

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

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

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

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

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

    Methods in io.vertx.reactivex.ext.auth.sqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SqlUserUtil.`createHashedUser​(String username, String hash)` | Insert a user into a database.
    `Future<Void>` | SqlUserUtil.`createRolePermission​(String role, String permission)` | Insert a role permission into a database.
    `Future<Void>` | SqlUserUtil.`createUser​(String username, String password)` | Insert a user into a database.
    `Future<Void>` | SqlUserUtil.`createUserRole​(String username, String role)` | Insert a user role into a database.
    `Future<Void>` | SqlAuthorization.`getAuthorizations​(User user)` | Updates the user with the set of authorizations.

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

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

    Method parameters in io.vertx.reactivex.ext.auth.webauthn with type arguments of type Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `Future<Boolean>` | BaseBridgeEvent.`future()` |

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

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

  - ### 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 | Description
    --- | --- | ---
    `Future<Void>` | TcpEventBusBridge.`close()` | Close the current socket.
    `Future<Boolean>` | BridgeEvent.`future()` |
    `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.reactivex.ext.healthchecks

    Methods in io.vertx.reactivex.ext.healthchecks that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<CheckResult>` | HealthChecks.`checkStatus()` | Invokes the registered procedures.
    `Future<CheckResult>` | HealthChecks.`checkStatus​(String name)` | Invokes the registered procedure with the given name and sub-procedures.
    `Future<JsonObject>` | HealthChecks.`invoke​(String name)` | Invokes the registered procedure with the given name and sub-procedures.

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

    Methods in io.vertx.reactivex.ext.mail that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MailClient.`close()` | Close the MailClient
    `Future<MailResult>` | MailClient.`sendMail​(MailMessage email)` | send a single mail via MailClient

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

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

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

    Methods in io.vertx.reactivex.ext.stomp that return Future
    Modifier and Type | Method | 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>` | StompClient.`close()` | Closes the client.
    `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()` | Connects to the server using the host and port configured in the client's options.
    `Future<StompClientConnection>` | StompClient.`connect​(int port, String host)` | Connects to the server.
    `Future<Frame>` | StompClientConnection.`disconnect()` | Disconnects the client.
    `Future<Frame>` | StompClientConnection.`disconnect​(Frame frame)` | Disconnects the client.
    `Future<StompServer>` | StompServer.`listen()` | Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `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)` | Called when the client connects to a server requiring authentication.
    `Future<Frame>` | StompClientConnection.`send​(Frame frame)` | Sends the given 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<Frame>` | StompClientConnection.`send​(Map<String,​String> headers, Buffer body)` | Sends a `SEND` frame to the server.
    `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.reactivex.ext.unit.report

    Methods in io.vertx.reactivex.ext.unit.report that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | TestSuiteReport.`pipeTo​(WriteStream<TestCaseReport> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

    Methods in io.vertx.reactivex.ext.web that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | FileUpload.`delete()` | Delete the uploaded file on the disk.
    `Future<Void>` | RoutingContext.`end()` | Shortcut to the response end.
    `Future<Void>` | RoutingContext.`end​(Buffer buffer)` | Shortcut to the response end.
    `Future<Void>` | RoutingContext.`end​(String chunk)` | Shortcut to the response end.
    `Future<Void>` | UserContext.`impersonate()` | Impersonates a second identity.
    `Future<Void>` | UserContext.`impersonate​(String redirectUri)` | Impersonates a second identity.
    `Future<Void>` | RoutingContext.`json​(Object json)` | Encode an Object to JSON and end the request.
    `Future<Void>` | UserContext.`logout()` | Logout can be called from any route handler which needs to terminate a login session.
    `Future<Void>` | UserContext.`logout​(String redirectUri)` | Logout can be called from any route handler which needs to terminate a login session.
    `Future<Void>` | RoutingContext.`redirect​(String url)` | Perform a 302 redirect to `url`.
    `Future<Void>` | UserContext.`refresh()` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`refresh​(String redirectUri)` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`restore()` | Undo a previous call to a impersonation.
    `Future<Void>` | UserContext.`restore​(String redirectUri)` | Undo a previous call to an impersonation.

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

    Methods in io.vertx.reactivex.ext.web.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<HttpResponse<T>>` | HttpRequest.`send()` | Send a request, the `handler` will receive the response as an `HttpResponse`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendBuffer​(Buffer body)` | Like `HttpRequest.send()` but with an HTTP request `body` buffer.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body, String charset)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJson​(Object body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJsonObject​(JsonObject body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendMultipartForm​(MultipartForm body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendStream​(Flowable<Buffer> body)` | Like `HttpRequest.send()` but with an HTTP request `body` stream.
    `Future<HttpResponse<T>>` | HttpRequest.`sendStream​(ReadStream<Buffer> body)` | Like `HttpRequest.send()` but with an HTTP request `body` stream.
    `Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

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

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

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

    Methods in io.vertx.reactivex.ext.web.handler that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SessionHandler.`flush​(RoutingContext ctx)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `Future<Void>` | SessionHandler.`flush​(RoutingContext ctx, boolean ignoreStatus)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `Future<Void>` | SessionHandler.`setUser​(RoutingContext context, User user)` | Set the user for the session

    Method parameters in io.vertx.reactivex.ext.web.handler with type arguments of type Future
    Modifier and Type | Method | 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.
    `APIKeyHandler` | APIKeyHandler.`tokenExtractor​(java.util.function.Function<String,​Future<String>> tokenExtractor)` | Transform from user's token format to the AuthenticationHandler's format.

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

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

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

    Methods in io.vertx.reactivex.ext.web.handler.sockjs that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SockJSSocket.`end()` | Call `SockJSSocket.close()`.
    `Future<Void>` | SockJSSocket.`end​(Buffer data)` | Same as `SockJSSocket.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Boolean>` | BridgeEvent.`future()` |
    `Future<Void>` | SockJSSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | SockJSSocket.`write​(Buffer data)` |
    `Future<Void>` | SockJSSocket.`write​(String data)` | Write a `String` to the socket, encoded in UTF-8.

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

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

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

    Methods in io.vertx.reactivex.ext.web.openapi.router that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<ValidatableRequest>` | RequestExtractor.`extractValidatableRequest​(RoutingContext routingContext, Operation operation)` | Extracts and transforms the parameters and the body of an incoming request into a that can be validated by the `RequestValidator`.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(Function<String,​Single<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(String callback, Function<String,​Single<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(String callback, java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.

    Method parameters in io.vertx.reactivex.ext.web.openapi.router with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(String callback, java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Future<RouterBuilder>` | Security.`openIdConnectHandler​(java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Single<RouterBuilder>` | Security.`rxOpenIdConnectHandler​(String callback, java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.
    `Single<RouterBuilder>` | Security.`rxOpenIdConnectHandler​(java.util.function.Function<String,​Future<OAuth2AuthHandler>> factory)` | Configure the to be used when creating the router.

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

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

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

    Methods in io.vertx.reactivex.grpc.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcClient.`close()` | Close this client.
    `Future<Void>` | GrpcClientRequest.`end()` | Ends the stream.
    `Future<Void>` | GrpcClientRequest.`end​(Req data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Resp>` | GrpcClientResponse.`last()` |
    `Future<Void>` | GrpcClientResponse.`pipeTo​(WriteStream<Resp> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request()` | Like `GrpcClient.request(io.vertx.core.net.Address)` with the default remote server.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request​(Address server)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(Address server, ServiceMethod<Resp,​Req> method)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(ServiceMethod<Resp,​Req> method)` | Like `GrpcClient.request(io.vertx.core.net.Address)` with the default remote server.
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`response()` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(Flowable<Req> body)` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(ReadStream<Req> body)` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(Req item)` |
    `Future<Void>` | GrpcClientRequest.`write​(Req data)` | Write some data to the stream.

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

    Methods in io.vertx.reactivex.grpc.common that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcReadStream.`end()` |
    `Future<Void>` | GrpcWriteStream.`end()` | Ends the stream.
    `Future<Void>` | GrpcWriteStream.`end​(T data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | GrpcWriteStream.`endMessage​(GrpcMessage message)` | End the stream with an encoded gRPC message.
    `Future<T>` | GrpcReadStream.`last()` |
    `Future<Void>` | GrpcReadStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | GrpcWriteStream.`write​(T data)` | Write some data to the stream.
    `Future<Void>` | GrpcWriteStream.`writeMessage​(GrpcMessage message)` | Write an encoded gRPC message.

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

    Methods in io.vertx.reactivex.grpc.server that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcServerResponse.`end()` | Ends the stream.
    `Future<Void>` | GrpcServerResponse.`end​(Resp data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Req>` | GrpcServerRequest.`last()` |
    `Future<Void>` | GrpcServerRequest.`pipeTo​(WriteStream<Req> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | GrpcServerResponse.`send​(Flowable<Resp> body)` |
    `Future<Void>` | GrpcServerResponse.`send​(ReadStream<Resp> body)` |
    `Future<Void>` | GrpcServerResponse.`send​(Resp item)` |
    `Future<Void>` | GrpcServerResponse.`write​(Resp data)` | Write some data to the stream.

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

    Methods in io.vertx.reactivex.jdbcclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Integer>` | JDBCConnection.`getTransactionIsolation()` |
    `Future<Void>` | JDBCConnection.`setTransactionIsolation​(int isolationLevel)` |

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

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

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

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

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

    Methods in io.vertx.reactivex.kafka.client.producer that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | KafkaProducer.`abortTransaction()` | Aborts the ongoing transaction.
    `Future<Void>` | KafkaProducer.`beginTransaction()` | Starts a new kafka transaction.
    `Future<Void>` | KafkaProducer.`close()` | Close the producer
    `Future<Void>` | KafkaProducer.`close​(long timeout)` | Close the producer
    `Future<Void>` | KafkaProducer.`commitTransaction()` | Commits the ongoing transaction.
    `Future<Void>` | KafkaProducer.`end()` | Ends the stream.
    `Future<Void>` | KafkaProducer.`end​(KafkaProducerRecord<K,​V> data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | KafkaProducer.`flush()` | Invoking this method makes all buffered records immediately available to write
    `Future<Void>` | KafkaProducer.`initTransactions()` | Initializes the underlying kafka transactional producer.
    `Future<List<PartitionInfo>>` | KafkaProducer.`partitionsFor​(String topic)` | Get the partition metadata for the give topic.
    `Future<RecordMetadata>` | KafkaProducer.`send​(KafkaProducerRecord<K,​V> record)` | Asynchronously write a record to a topic
    `Future<Void>` | KafkaProducer.`write​(KafkaProducerRecord<K,​V> data)` | Write some data to the stream.

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

    Methods in io.vertx.reactivex.mqtt that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MqttClient.`authenticationExchange​(MqttAuthenticationExchangeMessage message)` | It is used for Enhanced Authentication and is able to carry an authentication method and authentication data.
    `Future<Void>` | MqttServer.`close()` | Close the server.
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host)` | Connects to an MQTT server calling connectHandler after connection
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host, String serverName)` | Connects to an MQTT server calling connectHandler after connection
    `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, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT server
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT client
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttClient.`subscribe​(String topic, int qos)` | Subscribes to the topic with a specified QoS level
    `Future<Integer>` | MqttClient.`subscribe​(Map<String,​Integer> topics)` | Subscribes to the topics with related QoS levels
    `Future<Integer>` | MqttClient.`unsubscribe​(String topic)` | Unsubscribe from receiving messages on given topic
    `Future<Integer>` | MqttClient.`unsubscribe​(List<String> topics)` | Unsubscribe from receiving messages on given list of topic

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

    Methods in io.vertx.reactivex.mssqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, MSSQLConnectOptions connectOptions)` | Create a connection to SQL Server with the given `connectOptions`.
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MSSQLConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.mssqlclient.MSSQLConnectOptions)` with options built from `connectionUri`.

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

    Methods in io.vertx.reactivex.mysqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MySQLConnection.`changeUser​(MySQLAuthOptions options)` | Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, MySQLConnectOptions connectOptions)` | Create a connection to MySQL server with the given `connectOptions`.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MySQLConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions)` with options built from `connectionUri`.
    `Future<Void>` | MySQLConnection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<String>` | MySQLConnection.`getInternalStatistics()` | Send a STATISTICS command to get a human readable string of the server internal status.
    `Future<Void>` | MySQLConnection.`ping()` | Send a PING command to check if the server is alive.
    `Future<Void>` | MySQLConnection.`resetConnection()` | Send a RESET_CONNECTION command to reset the session state.
    `Future<Void>` | MySQLConnection.`setOption​(MySQLSetOption option)` | Send a SET_OPTION command to set options for the current connection.
    `Future<Void>` | MySQLConnection.`specifySchema​(String schemaName)` | Send a INIT_DB command to change the default schema of the connection.

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

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

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

    Methods in io.vertx.reactivex.openapi.validation that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<ValidatableRequest>` | ValidatableRequest.`of​(HttpServerRequest request, Operation operation)` | Creates a new `ValidatableRequest` object based on the passed and .
    `Future<Void>` | ValidatedResponse.`send​(HttpServerResponse serverResponse)` | Add all parameters from the validated response to the passed and send it.
    `Future<ValidatedRequest>` | RequestValidator.`validate​(HttpServerRequest request)` | Like `RequestValidator.validate(io.vertx.reactivex.core.http.HttpServerRequest)`, but the operationId and `ValidatableRequest` are determined from the passed request.
    `Future<ValidatedRequest>` | RequestValidator.`validate​(HttpServerRequest request, String operationId)` | Like `RequestValidator.validate(io.vertx.reactivex.core.http.HttpServerRequest)`, but `ValidatableRequest` are directly extracted from the passed request.
    `Future<ValidatedRequest>` | RequestValidator.`validate​(ValidatableRequest params, String operationId)` | Validates the passed request parameters against the operation defined in the related OpenAPI contract.

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

    Methods in io.vertx.reactivex.oracleclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, OracleConnectOptions connectOptions)` | Create a connection to Oracle with the given `connectOptions`.
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, String connectionUri)` | Like `OracleConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.oracleclient.OracleConnectOptions)` with options built from `connectionUri`.

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

    Methods in io.vertx.reactivex.pgclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgConnection.`cancelRequest()` | Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx)` | Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions)` with options build from the environment variables.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, PgConnectOptions options)` | Connects to the database and returns the connection if that succeeds.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, String connectionUri)` | Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions)` with options build from `connectionUri`.

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

    Methods in io.vertx.reactivex.pgclient.pubsub that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgSubscriber.`close()` | Close the subscriber, the retry policy will not be invoked.
    `Future<Void>` | PgSubscriber.`connect()` | Connect the subscriber to Postgres.
    `Future<Void>` | PgChannel.`pipeTo​(WriteStream<String> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

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

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

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

    Method parameters in io.vertx.reactivex.redis.client with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Redis` | Redis.`createClusterClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisClusterConnectOptions>> connectOptions)` | Creates a new cluster Redis client.
    `static Redis` | Redis.`createReplicationClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisReplicationConnectOptions>> connectOptions)` | Creates a new replication Redis client.
    `static Redis` | Redis.`createSentinelClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisSentinelConnectOptions>> connectOptions)` | Creates a new sentinel Redis client.
    `static Redis` | Redis.`createStandaloneClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)` | Creates a new standalone Redis client.

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

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

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

    Methods in io.vertx.reactivex.servicediscovery.spi that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Record>` | ServicePublisher.`publish​(Record record)` | Publishes a record.
    `Future<Void>` | ServicePublisher.`unpublish​(String id)` | Un-publishes a record.
    `Future<Record>` | ServicePublisher.`update​(Record record)` | Updates an existing record.

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

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

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

    Methods in io.vertx.reactivex.sqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Transaction>` | SqlConnection.`begin()` | Begin a transaction and returns a `Transaction` for controlling and tracking this transaction.
    `Future<Void>` | Cursor.`close()` | Release the cursor.
    `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()` | Close the client and release the associated resources.
    `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>` | PreparedQuery.`execute()` | Execute the query.
    `Future<T>` | PreparedQuery.`execute​(Tuple tuple)` | Execute the query.
    `Future<T>` | Query.`execute()` | Execute the query.
    `Future<T>` | PreparedQuery.`executeBatch​(List<Tuple> batch)` | Execute the query with a batch of tuples.
    `Future<SqlConnection>` | Pool.`getConnection()` | Get a connection from the pool.
    `Future<Void>` | RowStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql)` | Create a prepared statement using the given `sql` string.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql, PrepareOptions options)` | Create a prepared statement using the given `sql` string.
    `Future<RowSet<Row>>` | Cursor.`read​(int count)` | Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `Future<Void>` | Transaction.`rollback()` | Rollback the transaction and release the associated resources.
    `<T> Future<T>` | Pool.`withConnection​(Function<SqlConnection,​Maybe<T>> function)` | Get a connection from the pool and execute the given `function`.
    `<T> Future<T>` | Pool.`withConnection​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Get a connection from the pool and execute the given `function`.
    `<T> Future<T>` | Pool.`withTransaction​(Function<SqlConnection,​Maybe<T>> function)` | Execute the given `function` within a transaction.
    `<T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, Function<SqlConnection,​Maybe<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.

    Method parameters in io.vertx.reactivex.sqlclient with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClientBuilder<C>` | ClientBuilder.`connectingTo​(java.util.function.Supplier<Future<SqlConnectOptions>> supplier)` | Configure the `database` the client should connect to.
    `<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​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Maybe<T>` | Pool.`rxWithTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.
    `<T> Future<T>` | Pool.`withConnection​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Get a connection from the pool and execute the given `function`.
    `<T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.reactivex.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.

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

    Methods in io.vertx.reactivex.sqlclient.templates that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<R>` | SqlTemplate.`execute​(I params)` | Execute the query with the `parameters`
    `Future<R>` | SqlTemplate.`executeBatch​(List<I> batch)` | Execute a batch query with the `batch`.

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

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

    Method parameters in io.vertx.redis.client with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Redis` | Redis.`createClusterClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisClusterConnectOptions>> connectOptions)` | Creates a new cluster Redis client.
    `static Redis` | Redis.`createReplicationClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisReplicationConnectOptions>> connectOptions)` | Creates a new replication Redis client.
    `static Redis` | Redis.`createSentinelClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisSentinelConnectOptions>> connectOptions)` | Creates a new sentinel Redis client.
    `static Redis` | Redis.`createStandaloneClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)` | Creates a new standalone Redis client.

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

    Methods in io.vertx.rxjava.amqp that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | AmqpClient.`close()` | Closes the client.
    `Future<Void>` | AmqpConnection.`close()` | Closes the AMQP connection, i.e.
    `Future<Void>` | AmqpReceiver.`close()` | Closes the receiver.
    `Future<Void>` | AmqpSender.`close()` | Closes the sender.
    `Future<Void>` | AmqpConnection.`closeFuture()` |
    `Future<AmqpConnection>` | AmqpClient.`connect()` | Connects to the AMQP broker or router.
    `Future<AmqpSender>` | AmqpConnection.`createAnonymousSender()` | Creates an anonymous sender.
    `Future<AmqpReceiver>` | AmqpConnection.`createDynamicReceiver()` | Creates a dynamic receiver.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpClient.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address)` | Creates a receiver used to consume messages from the given address.
    `Future<AmqpReceiver>` | AmqpConnection.`createReceiver​(String address, AmqpReceiverOptions receiverOptions)` | Creates a receiver used to consumer messages from the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpClient.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address)` | Creates a sender used to send messages to the given address.
    `Future<AmqpSender>` | AmqpConnection.`createSender​(String address, AmqpSenderOptions options)` | Creates a sender used to send messages to the given address.
    `Future<Void>` | AmqpSender.`end()` | Ends the stream.
    `Future<Void>` | AmqpSender.`end​(AmqpMessage data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | AmqpReceiver.`pipeTo​(WriteStream<AmqpMessage> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | AmqpSender.`sendWithAck​(AmqpMessage message)` | Sends an AMQP message and waits for an acknowledgement.
    `Future<Void>` | AmqpSender.`write​(AmqpMessage data)` | Write some data to the stream.

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

    Methods in io.vertx.rxjava.cassandra that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | ResultSet.`all()` | The method should not be used concurrently with others like `ResultSet.fetchNextPage()` or `ResultSet.one()`.
    `Future<Void>` | CassandraClient.`close()` | Closes this client.
    `Future<ResultSet>` | CassandraClient.`execute​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the statement and provide a handler for consuming results.
    `Future<ResultSet>` | CassandraClient.`execute​(String query)` | Execute the query and provide a handler for consuming results.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Execute the query and provide a handler for consuming results.
    `Future<List<com.datastax.oss.driver.api.core.cql.Row>>` | CassandraClient.`executeWithFullFetch​(String query)` | Execute the query and provide a handler for consuming results.
    `Future<ResultSet>` | ResultSet.`fetchNextPage()` |
    `Future<com.datastax.oss.driver.api.core.metadata.Metadata>` | CassandraClient.`metadata()` | Get for the session.
    `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)` | Prepares the provided a .
    `Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>` | CassandraClient.`prepare​(String query)` | Prepares the provided query string.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(com.datastax.oss.driver.api.core.cql.Statement statement)` | Executes the given SQL statement which returns the results of the query as a read stream.
    `Future<CassandraRowStream>` | CassandraClient.`queryStream​(String sql)` | Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

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

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

    Methods in io.vertx.rxjava.circuitbreaker with parameters of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | FailurePolicy.`test​(Future<T> future)` | Invoked by the `CircuitBreaker` when an operation completes.

    Method parameters in io.vertx.rxjava.circuitbreaker with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(java.util.function.Supplier<Future<T>> command, java.util.function.Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | CircuitBreaker.`rxExecute​(java.util.function.Supplier<Future<T>> command)` | Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback​(java.util.function.Supplier<Future<T>> command, java.util.function.Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.

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

    Methods in io.vertx.rxjava.config that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | ConfigRetriever.`close()` | Closes the retriever.
    `Future<JsonObject>` | ConfigRetriever.`getConfig()` | Reads the configuration from the different and computes the final configuration.

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

    Methods in io.vertx.rxjava.core that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Vertx>` | VertxBuilder.`buildClustered()` | Creates a clustered instance.
    `Future<Void>` | Vertx.`close()` | Stop the Vertx instance and release any resources held by it.
    `Future<Void>` | WorkerExecutor.`close()` | Close the executor.
    `static Future<Vertx>` | Vertx.`clusteredVertx​(VertxOptions options)` | Creates a clustered instance using the specified options.
    `Future<String>` | Vertx.`deployVerticle​(Deployable verticle)` | Deploy a verticle instance that you have created yourself.
    `Future<String>` | Vertx.`deployVerticle​(Deployable verticle, DeploymentOptions options)` | Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `Future<String>` | Vertx.`deployVerticle​(String name)` | Deploy a verticle instance given a name.
    `Future<String>` | Vertx.`deployVerticle​(String name, DeploymentOptions options)` | Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `<T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler)` | Invoke `Context.executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
    `<T> Future<T>` | Context.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `<T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `Vertx.executeBlocking(java.util.concurrent.Callable<T>, boolean)` called with ordered = true.
    `<T> Future<T>` | Vertx.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `<T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler)` | Like `WorkerExecutor.executeBlocking(java.util.concurrent.Callable<T>, boolean)` called with ordered = true.
    `<T> Future<T>` | WorkerExecutor.`executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `Future<T>` | Promise.`future()` |
    `Future<Void>` | Vertx.`undeploy​(String deploymentID)` | Undeploy a verticle deployment.

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

    Methods in io.vertx.rxjava.core.datagram that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String sourceToBlock)` | Block the given address for the given multicast address and notifies the once the operation completes.
    `Future<Void>` | DatagramSocket.`blockMulticastGroup​(String multicastAddress, String networkInterface, String sourceToBlock)` | Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `Future<Void>` | DatagramSocket.`close()` | Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `Future<DatagramSocket>` | DatagramSocket.`listen​(int port, String host)` | Start listening on the given port and host.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress)` | Joins a multicast group and listens for packets send to it.
    `Future<Void>` | DatagramSocket.`listenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Joins a multicast group and listens for packets send to it on the given network interface.
    `Future<Void>` | DatagramSocket.`send​(Buffer packet, int port, String host)` | Write the given `Buffer` to the `SocketAddress`.
    `Future<Void>` | DatagramSocket.`send​(String str, int port, String host)` | Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `Future<Void>` | DatagramSocket.`send​(String str, String enc, int port, String host)` | Write the given `String` to the `SocketAddress` using the given encoding.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress)` | Leaves a multicast group and stops listening for packets send to it.
    `Future<Void>` | DatagramSocket.`unlistenMulticastGroup​(String multicastAddress, String networkInterface, String source)` | Leaves a multicast group and stops listening for packets send to it on the given network interface.

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

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

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

    Methods in io.vertx.rxjava.core.eventbus that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MessageProducer.`close()` | Closes the producer, this method should be called when the message producer is not used anymore.
    `Future<Void>` | MessageConsumer.`completion()` |
    `Future<Void>` | MessageConsumer.`pipeTo​(WriteStream<Message<T>> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `<R> Future<Message<R>>` | Message.`replyAndRequest​(Object message)` | Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<R> Future<Message<R>>` | Message.`replyAndRequest​(Object message, DeliveryOptions options)` | Like `Message.replyAndRequest(java.lang.Object)` but specifying `options` that can be used to configure the delivery.
    `<T> Future<Message<T>>` | EventBus.`request​(String address, Object message)` | Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> Future<Message<T>>` | EventBus.`request​(String address, Object message, DeliveryOptions options)` | Like `EventBus.request(java.lang.String, java.lang.Object)` but specifying `options` that can be used to configure the delivery.
    `Future<Void>` | MessageConsumer.`unregister()` | Unregisters the handler which created this registration
    `Future<Void>` | MessageProducer.`write​(T body)` | Write a message to the event-bus, either sending or publishing.

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

    Methods in io.vertx.rxjava.core.file that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | FileSystem.`chmod​(String path, String perms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chmodRecursive​(String path, String perms, String dirPerms)` | Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `Future<Void>` | FileSystem.`chown​(String path, String user, String group)` | Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `Future<Void>` | AsyncFile.`close()` | Close the file.
    `Future<Void>` | FileSystem.`copy​(String from, String to)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copy​(String from, String to, CopyOptions options)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`copyRecursive​(String from, String to, boolean recursive)` | Copy a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path)` | Creates an empty file with the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`createFile​(String path, String perms)` | Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String prefix, String perms)` | Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempDirectory​(String dir, String prefix, String perms)` | Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix)` | Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | FileSystem.`createTempFile​(String dir, String prefix, String suffix, String perms)` | Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<Void>` | FileSystem.`delete​(String path)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Void>` | FileSystem.`deleteRecursive​(String path, boolean recursive)` | Deletes the file represented by the specified `path`, asynchronously.
    `Future<Void>` | AsyncFile.`end()` | Ends the stream.
    `Future<Void>` | AsyncFile.`end​(Buffer data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Boolean>` | FileSystem.`exists​(String path)` | Determines whether the file as specified by the path `path` exists, asynchronously.
    `Future<Void>` | AsyncFile.`flush()` | Flush any writes made to this file to underlying persistent storage.
    `Future<FileSystemProps>` | FileSystem.`fsProps​(String path)` | Returns properties of the file-system being used by the specified `path`, asynchronously.
    `Future<Boolean>` | AsyncFileLock.`isValid()` | A lock remains valid until it is released or the file corresponding `AsyncFile` is closed.
    `Future<Void>` | FileSystem.`link​(String link, String existing)` | Create a hard link on the file system from `link` to `existing`, asynchronously.
    `Future<AsyncFileLock>` | AsyncFile.`lock()` | Acquire a non-shared lock on the entire file.
    `Future<AsyncFileLock>` | AsyncFile.`lock​(long position, long size, boolean shared)` | Acquire a lock on a portion of this file.
    `Future<FileProps>` | FileSystem.`lprops​(String path)` | Obtain properties for the link represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdir​(String path, String perms)` | Create the directory represented by `path`, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`mkdirs​(String path, String perms)` | Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<Void>` | FileSystem.`move​(String from, String to, CopyOptions options)` | Move a file from the path `from` to path `to`, asynchronously.
    `Future<AsyncFile>` | FileSystem.`open​(String path, OpenOptions options)` | Open the file represented by `path`, asynchronously.
    `Future<Void>` | AsyncFile.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<FileProps>` | FileSystem.`props​(String path)` | Obtain properties for the file represented by `path`, asynchronously.
    `Future<Buffer>` | AsyncFile.`read​(Buffer buffer, int offset, long position, int length)` | Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<List<String>>` | FileSystem.`readDir​(String path, String filter)` | Read the contents of the directory specified by `path`, asynchronously.
    `Future<Buffer>` | FileSystem.`readFile​(String path)` | Reads the entire file as represented by the path `path` as a , asynchronously.
    `Future<String>` | FileSystem.`readSymlink​(String link)` | Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `Future<Void>` | AsyncFileLock.`release()` | Releases this lock;
    `Future<Long>` | AsyncFile.`size()` |
    `Future<Void>` | FileSystem.`symlink​(String link, String existing)` | Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `Future<Void>` | FileSystem.`truncate​(String path, long len)` | Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `Future<Void>` | FileSystem.`unlink​(String link)` | Unlinks the link on the file system represented by the path `link`, asynchronously.
    `<T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.
    `Future<Void>` | AsyncFile.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | AsyncFile.`write​(Buffer buffer, long position)` | Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `Future<Void>` | FileSystem.`writeFile​(String path, Buffer data)` | Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

    Method parameters in io.vertx.rxjava.core.file with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Single<T>` | AsyncFile.`rxWithLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Single<T>` | AsyncFile.`rxWithLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.
    `<T> Future<T>` | AsyncFile.`withLock​(long position, long size, boolean shared, java.util.function.Supplier<Future<T>> block)` | Acquire a lock on a portion of this file.
    `<T> Future<T>` | AsyncFile.`withLock​(java.util.function.Supplier<Future<T>> block)` | Acquire a non-shared lock on the entire file.

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

    Methods in io.vertx.rxjava.core.http that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<ServerWebSocket>` | ServerWebSocketHandshake.`accept()` | Accept the WebSocket and terminate the WebSocket handshake.
    `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>` | ClientWebSocket.`close()` | Close the WebSocket sending the default close frame.
    `Future<Void>` | ClientWebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | ClientWebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `Future<Void>` | HttpClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpClientAgent.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpClientConnection.`close()` |
    `Future<Void>` | HttpConnection.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | HttpServer.`close()` | Close the server.
    `Future<Void>` | ServerWebSocket.`close()` | The WebSocket handshake will be accepted when it hasn't yet been settled or when an asynchronous handshake is in progress.
    `Future<Void>` | ServerWebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | ServerWebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `Future<Void>` | WebSocket.`close()` | Close the WebSocket sending the default close frame.
    `Future<Void>` | WebSocket.`close​(short statusCode)` | Close the WebSocket sending a close frame with specified status code.
    `Future<Void>` | WebSocket.`close​(short statusCode, String reason)` | Close sending a close frame with specified status code and reason.
    `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<Void>` | WebSocketClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<WebSocket>` | ClientWebSocket.`connect​(int port, String host, String requestURI)` | Connect this WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | ClientWebSocket.`connect​(WebSocketConnectOptions options)` | Connect this WebSocket with the specified options.
    `Future<WebSocket>` | ClientWebSocket.`connect​(String requestURI)` | Connect this WebSocket at the relative request URI using the default host and port.
    `Future<WebSocket>` | ClientWebSocket.`connect​(String host, String requestURI)` | Connect this WebSocket to the host and relative request URI and default port.
    `Future<HttpClientConnection>` | HttpClientAgent.`connect​(HttpConnectOptions options)` | Connect to a remote HTTP server with the specific `options`, the connection is un-pooled and the management of the connection is left to the user.
    `Future<HttpClientResponse>` | HttpClientRequest.`connect()` | Create an HTTP tunnel to the server.
    `Future<WebSocket>` | WebSocketClient.`connect​(int port, String host, String requestURI)` | Connect a WebSocket to the specified port, host and relative request URI.
    `Future<WebSocket>` | WebSocketClient.`connect​(WebSocketConnectOptions options)` | Connect a WebSocket with the specified options.
    `Future<WebSocket>` | WebSocketClient.`connect​(String requestURI)` | Connect a WebSocket to the default client port, default client host and specified, relative request URI.
    `Future<WebSocket>` | WebSocketClient.`connect​(String host, String requestURI)` | Connect a WebSocket to the default client port and specified host and relative request URI.
    `Future<Void>` | ClientWebSocket.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | ClientWebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | HttpClientRequest.`end()` | Ends the request.
    `Future<Void>` | HttpClientRequest.`end​(Buffer chunk)` | Same as `HttpClientRequest.end(java.lang.String)` but writes some data to the request body before ending.
    `Future<Void>` | HttpClientRequest.`end​(String chunk)` | Same as `HttpClientRequest.end(java.lang.String)` but writes a String in UTF-8 encoding
    `Future<Void>` | HttpClientRequest.`end​(String chunk, String enc)` | Same as `HttpClientRequest.end(java.lang.String)` but writes a String with the specified encoding
    `Future<Void>` | HttpClientResponse.`end()` | Returns a future signaling when the response has been fully received successfully or failed.
    `Future<Void>` | HttpServerRequest.`end()` | Returns a future signaling when the request has been fully received successfully or failed.
    `Future<Void>` | HttpServerResponse.`end()` | Ends the response.
    `Future<Void>` | HttpServerResponse.`end​(Buffer chunk)` | Same as `HttpServerResponse.end(java.lang.String)` but writes some data to the response body before ending.
    `Future<Void>` | HttpServerResponse.`end​(String chunk)` | Same as `HttpServerResponse.end(java.lang.String)` but writes a String in UTF-8 encoding before ending the response.
    `Future<Void>` | HttpServerResponse.`end​(String chunk, String enc)` | Same as `HttpServerResponse.end(java.lang.String)` but writes a String with the specified encoding before ending the response.
    `Future<Void>` | ServerWebSocket.`end()` | Calls `ServerWebSocket.close(short)`
    `Future<Void>` | ServerWebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | WebSocket.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | WebSocket.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Void>` | WebSocketBase.`end()` | Calls `WebSocketBase.close()`
    `Future<Void>` | WebSocketBase.`end​(Buffer data)` | Same as `WebSocketBase.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<HttpServer>` | HttpServer.`listen()` | Tell the server to start listening.
    `Future<HttpServer>` | HttpServer.`listen​(int port)` | Like `HttpServer.listen()` 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)` | Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `Future<Buffer>` | HttpConnection.`ping​(Buffer data)` | Send a frame to the remote endpoint.
    `Future<Void>` | ClientWebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpClientResponse.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpServerFileUpload.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | HttpServerRequest.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | ServerWebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | WebSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | WebSocketBase.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, HostAndPort authority, String path, MultiMap headers)` | Push a response to the client.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String path, MultiMap headers)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with the host copied from the current request.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path)` | Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String)` with no headers.
    `Future<HttpServerResponse>` | HttpServerResponse.`push​(HttpMethod method, String host, String path, MultiMap headers)` | Deprecated.
    `Future<Void>` | ServerWebSocketHandshake.`reject()` | Reject the WebSocket.
    `Future<Void>` | ServerWebSocketHandshake.`reject​(int status)` | Like `ServerWebSocketHandshake.reject()` but with a `status`.
    `Future<HttpClientRequest>` | HttpClient.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClient.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClient.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientRequest>` | HttpClientAgent.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClientAgent.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientRequest>` | HttpClientConnection.`request()` | Create an HTTP request to send to the server with the default host and port of the client.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, int port, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and `port`.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, String requestURI)` | Create an HTTP request to send to the server at the default host and port.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(HttpMethod method, String host, String requestURI)` | Create an HTTP request to send to the server at the `host` and default port.
    `Future<HttpClientRequest>` | HttpClientConnection.`request​(RequestOptions options)` | Create an HTTP request to send to the server.
    `Future<HttpClientResponse>` | HttpClientRequest.`response()` |
    `Future<HttpClientResponse>` | HttpClientRequest.`send()` | Send the request with an empty body.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(Buffer body)` | Send the request with a buffer `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(String body)` | Send the request with a string `body`.
    `Future<HttpClientResponse>` | HttpClientRequest.`send​(Observable<Buffer> body)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`send()` | Send the request with an empty body.
    `Future<Void>` | HttpServerResponse.`send​(Buffer body)` | Send the request with a buffer `body`.
    `Future<Void>` | HttpServerResponse.`send​(ReadStream<Buffer> body)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`send​(String body)` | Send the request with a string `body`.
    `Future<Void>` | HttpServerResponse.`send​(Observable<Buffer> body)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`sendFile​(String filename)` | Send the request with a stream `body`.
    `Future<Void>` | HttpServerResponse.`sendFile​(String filename, long offset)` | Same as `HttpServerResponse.sendFile(java.lang.String)` 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(java.lang.String)` is called on the request or any data is written to it.
    `Future<Void>` | ClientWebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | ClientWebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | ClientWebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | HttpClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpClientAgent.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpClientAgent.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpClientConnection.`shutdown()` |
    `Future<Void>` | HttpClientConnection.`shutdown​(long timeout, TimeUnit unit)` |
    `Future<Void>` | HttpConnection.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpConnection.`shutdown​(long timeout, TimeUnit unit)` | Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a `timeout` the connection will be closed.
    `Future<Void>` | HttpServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | HttpServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `Future<Void>` | ServerWebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | ServerWebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | ServerWebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocket.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | WebSocket.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | WebSocket.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocketBase.`shutdown()` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout, the status code `1000` a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit)` | Calls `WebSocketBase.shutdown()` with the status code `1000` and a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode)` | Calls `WebSocketBase.shutdown()` with a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(long timeout, TimeUnit unit, short statusCode, String reason)` | Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a `timeout` the WebSocket will be closed.
    `Future<Void>` | WebSocketBase.`shutdown​(short statusCode)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout and a `null` reason.
    `Future<Void>` | WebSocketBase.`shutdown​(short statusCode, String reason)` | Like `WebSocketBase.shutdown()` with a 30 seconds timeout.
    `Future<Void>` | WebSocketClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | WebSocketClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | HttpServerFileUpload.`streamToFileSystem​(String filename)` | Stream the content of this upload to the given file on storage.
    `Future<NetSocket>` | HttpServerRequest.`toNetSocket()` | Establish a TCP tunnel with the client.
    `Future<ServerWebSocket>` | HttpServerRequest.`toWebSocket()` | Upgrade the connection of the current request to a WebSocket.
    `Future<Void>` | HttpConnection.`updateSettings​(Http2Settings settings)` | Send to the remote endpoint an update of this endpoint settings
    `Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpClientAgent.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | HttpServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebSocketClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | ClientWebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpClientRequest.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpClientRequest.`write​(String chunk)` | Write a `String` to the request body, encoded as UTF-8.
    `Future<Void>` | HttpClientRequest.`write​(String chunk, String enc)` | Write a `String` to the request body, encoded using the encoding `enc`.
    `Future<Void>` | HttpServerResponse.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | HttpServerResponse.`write​(String chunk)` | Write a `String` to the response body, encoded in UTF-8.
    `Future<Void>` | HttpServerResponse.`write​(String chunk, String enc)` | Write a `String` to the response body, encoded using the encoding `enc`.
    `Future<Void>` | ServerWebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | WebSocket.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | WebSocketBase.`write​(Buffer data)` | Write some data to the stream.
    `Future<Void>` | ClientWebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | ServerWebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | WebSocket.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | WebSocketBase.`writeBinaryMessage​(Buffer data)` | Writes a (potentially large) piece of binary data to the connection.
    `Future<Void>` | HttpServerResponse.`writeContinue()` | Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
    `Future<Void>` | HttpClientRequest.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
    `Future<Void>` | HttpClientRequest.`writeCustomFrame​(HttpFrame frame)` | Like `HttpClientRequest.writeCustomFrame(int, int, io.vertx.core.buffer.Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeCustomFrame​(int type, int flags, Buffer payload)` | Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
    `Future<Void>` | HttpServerResponse.`writeCustomFrame​(HttpFrame frame)` | Like `HttpServerResponse.writeCustomFrame(int, int, io.vertx.core.buffer.Buffer)` but with an `HttpFrame`.
    `Future<Void>` | HttpServerResponse.`writeEarlyHints​(MultiMap headers)` | Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
    `Future<Void>` | ClientWebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocket.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalBinaryFrame​(Buffer data)` | Write a final WebSocket binary frame to the connection
    `Future<Void>` | ClientWebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocket.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | WebSocketBase.`writeFinalTextFrame​(String text)` | Write a final WebSocket text frame to the connection
    `Future<Void>` | ClientWebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | ServerWebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | WebSocket.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | WebSocketBase.`writeFrame​(WebSocketFrame frame)` | Write a WebSocket frame to the connection
    `Future<Void>` | ClientWebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | ServerWebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | WebSocket.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | WebSocketBase.`writePing​(Buffer data)` | Writes a ping frame to the connection.
    `Future<Void>` | ClientWebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | ServerWebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | WebSocket.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | WebSocketBase.`writePong​(Buffer data)` | Writes a pong frame to the connection.
    `Future<Void>` | ClientWebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | ServerWebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | WebSocket.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.
    `Future<Void>` | WebSocketBase.`writeTextMessage​(String text)` | Writes a (potentially large) piece of text data to the connection.

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

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

    Methods in io.vertx.rxjava.core.net that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | NetClient.`close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<Void>` | NetServer.`close()` | Close the server.
    `Future<Void>` | NetSocket.`close()` | Close the socket
    `Future<NetSocket>` | NetClient.`connect​(int port, String host)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(int port, String host, String serverName)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | NetClient.`connect​(ConnectOptions connectOptions)` | Open a connection to a server at the specific `connectOptions`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<NetSocket>` | NetClient.`connect​(SocketAddress remoteAddress, String serverName)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<Void>` | NetSocket.`end()` | Calls `NetSocket.close()`
    `Future<Void>` | NetSocket.`end​(Buffer data)` | Same as `NetSocket.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `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.
    `Future<Void>` | NetSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `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.
    `Future<Void>` | NetSocket.`sendFile​(String filename, long offset)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetSocket.`sendFile​(String filename, long offset, long length)` | Tell the operating system to stream a file as specified by `filename` directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
    `Future<Void>` | NetClient.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetClient.`shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Future<Void>` | NetServer.`shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | NetServer.`shutdown​(long timeout, TimeUnit unit)` | Initiate the server shutdown sequence.
    `Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | NetServer.`updateSSLOptions​(ServerSSLOptions options, boolean force)` | Update the server with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | NetSocket.`upgradeToSsl()` | Like `NetSocket.upgradeToSsl()` with the default SSL options, without indicating a server name, without an upgrade message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(Buffer msg)` | Like `NetSocket.upgradeToSsl()` with the default SSL options and without indicating a server name.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions)` | Upgrade channel to use SSL/TLS.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, Buffer msg)` | Like `NetSocket.upgradeToSsl()` without indicating a server name
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName)` | Like `NetSocket.upgradeToSsl()` without an upgrade message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(SSLOptions sslOptions, String serverName, Buffer upgrade)` | Upgrade the channel to use SSL/TLS, in other words proceeds to the TLS handshake.
    `Future<Void>` | NetSocket.`upgradeToSsl​(String serverName)` | Like `NetSocket.upgradeToSsl()` with the default SSL options and without an update message.
    `Future<Void>` | NetSocket.`upgradeToSsl​(String serverName, Buffer msg)` | Like `NetSocket.upgradeToSsl()` with the default SSL options.
    `Future<Void>` | NetSocket.`write​(Buffer data)` | Write some data to the stream.
    `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.rxjava.core.net.endpoint

    Methods in io.vertx.rxjava.core.net.endpoint that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Endpoint>` | EndpointResolver.`resolveEndpoint​(Address address)` | Resolver an endpoint for the specified `address`

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

    Methods in io.vertx.rxjava.core.parsetools that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | JsonParser.`pipeTo​(WriteStream<JsonEvent> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | RecordParser.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

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

    Method parameters in io.vertx.rxjava.core.shareddata with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Single<T>` | SharedData.`rxWithLocalLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLocalLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Single<T>` | SharedData.`rxWithLocalLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous local lock with the specified name.
    `<T> Single<T>` | SharedData.`rxWithLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Single<T>` | SharedData.`rxWithLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous lock with the specified name.
    `<T> Future<T>` | SharedData.`withLocalLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLocalLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Future<T>` | SharedData.`withLocalLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous local lock with the specified name.
    `<T> Future<T>` | SharedData.`withLock​(String name, long timeout, java.util.function.Supplier<Future<T>> block)` | Like `SharedData.withLock(java.lang.String, java.util.function.Supplier<io.vertx.core.Future<T>>)` but specifying a timeout.
    `<T> Future<T>` | SharedData.`withLock​(String name, java.util.function.Supplier<Future<T>> block)` | Get an asynchronous lock with the specified name.

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

    Methods in io.vertx.rxjava.core.streams that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | WriteStream.`end()` | Ends the stream.
    `Future<Void>` | WriteStream.`end​(T data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | ReadStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | Pipe.`to​(WriteStream<T> dst)` | Start to pipe the elements to the destination `WriteStream`.
    `Future<Void>` | WriteStream.`write​(T data)` | Write some data to the stream.

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

    Methods in io.vertx.rxjava.db2client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, DB2ConnectOptions connectOptions)` | Create a connection to DB2 server with the given `connectOptions`.
    `static Future<DB2Connection>` | DB2Connection.`connect​(Vertx vertx, String connectionUri)` | Like `DB2Connection.connect(io.vertx.rxjava.core.Vertx, io.vertx.db2client.DB2ConnectOptions)` with options build from `connectionUri`.
    `Future<Void>` | DB2Connection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<Void>` | DB2Connection.`ping()` | Send a PING command to check if the server is alive.

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

    Methods in io.vertx.rxjava.ext.auth.authentication that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<User>` | AuthenticationProvider.`authenticate​(Credentials credentials)` | Authenticate a user.

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

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

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

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

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

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

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

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

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

    Methods in io.vertx.rxjava.ext.auth.oauth2.providers that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OAuth2Auth>` | AmazonCognitoAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static Future<OAuth2Auth>` | AppleIdAuth.`discover​(Vertx vertx, PubSecKeyOptions privateKey, 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>` | GoogleAuth.`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>` | KeycloakAuth.`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>` | SalesforceAuth.`discover​(Vertx vertx, OAuth2Options config)` | Create a OAuth2Auth provider for OpenID Connect Discovery.

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

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

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

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

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

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

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

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

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

    Methods in io.vertx.rxjava.ext.auth.sqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SqlUserUtil.`createHashedUser​(String username, String hash)` | Insert a user into a database.
    `Future<Void>` | SqlUserUtil.`createRolePermission​(String role, String permission)` | Insert a role permission into a database.
    `Future<Void>` | SqlUserUtil.`createUser​(String username, String password)` | Insert a user into a database.
    `Future<Void>` | SqlUserUtil.`createUserRole​(String username, String role)` | Insert a user role into a database.
    `Future<Void>` | SqlAuthorization.`getAuthorizations​(User user)` | Updates the user with the set of authorizations.

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

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

    Method parameters in io.vertx.rxjava.ext.auth.webauthn with type arguments of type Future
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `Future<Boolean>` | BaseBridgeEvent.`future()` |

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

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

  - ### 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 | Description
    --- | --- | ---
    `Future<Void>` | TcpEventBusBridge.`close()` | Close the current socket.
    `Future<Boolean>` | BridgeEvent.`future()` |
    `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.rxjava.ext.healthchecks

    Methods in io.vertx.rxjava.ext.healthchecks that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<CheckResult>` | HealthChecks.`checkStatus()` | Invokes the registered procedures.
    `Future<CheckResult>` | HealthChecks.`checkStatus​(String name)` | Invokes the registered procedure with the given name and sub-procedures.
    `Future<JsonObject>` | HealthChecks.`invoke​(String name)` | Invokes the registered procedure with the given name and sub-procedures.

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

    Methods in io.vertx.rxjava.ext.mail that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MailClient.`close()` | Close the MailClient
    `Future<MailResult>` | MailClient.`sendMail​(MailMessage email)` | send a single mail via MailClient

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

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

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

    Methods in io.vertx.rxjava.ext.stomp that return Future
    Modifier and Type | Method | 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>` | StompClient.`close()` | Closes the client.
    `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()` | Connects to the server using the host and port configured in the client's options.
    `Future<StompClientConnection>` | StompClient.`connect​(int port, String host)` | Connects to the server.
    `Future<Frame>` | StompClientConnection.`disconnect()` | Disconnects the client.
    `Future<Frame>` | StompClientConnection.`disconnect​(Frame frame)` | Disconnects the client.
    `Future<StompServer>` | StompServer.`listen()` | Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `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)` | Called when the client connects to a server requiring authentication.
    `Future<Frame>` | StompClientConnection.`send​(Frame frame)` | Sends the given 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<Frame>` | StompClientConnection.`send​(Map<String,​String> headers, Buffer body)` | Sends a `SEND` frame to the server.
    `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.rxjava.ext.unit.report

    Methods in io.vertx.rxjava.ext.unit.report that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | TestSuiteReport.`pipeTo​(WriteStream<TestCaseReport> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

    Methods in io.vertx.rxjava.ext.web that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | FileUpload.`delete()` | Delete the uploaded file on the disk.
    `Future<Void>` | RoutingContext.`end()` | Shortcut to the response end.
    `Future<Void>` | RoutingContext.`end​(Buffer buffer)` | Shortcut to the response end.
    `Future<Void>` | RoutingContext.`end​(String chunk)` | Shortcut to the response end.
    `Future<Void>` | UserContext.`impersonate()` | Impersonates a second identity.
    `Future<Void>` | UserContext.`impersonate​(String redirectUri)` | Impersonates a second identity.
    `Future<Void>` | RoutingContext.`json​(Object json)` | Encode an Object to JSON and end the request.
    `Future<Void>` | UserContext.`logout()` | Logout can be called from any route handler which needs to terminate a login session.
    `Future<Void>` | UserContext.`logout​(String redirectUri)` | Logout can be called from any route handler which needs to terminate a login session.
    `Future<Void>` | RoutingContext.`redirect​(String url)` | Perform a 302 redirect to `url`.
    `Future<Void>` | UserContext.`refresh()` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`refresh​(String redirectUri)` | Forces the current user to re-authenticate.
    `Future<Void>` | UserContext.`restore()` | Undo a previous call to a impersonation.
    `Future<Void>` | UserContext.`restore​(String redirectUri)` | Undo a previous call to an impersonation.

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

    Methods in io.vertx.rxjava.ext.web.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<HttpResponse<T>>` | HttpRequest.`send()` | Send a request, the `handler` will receive the response as an `HttpResponse`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendBuffer​(Buffer body)` | Like `HttpRequest.send()` but with an HTTP request `body` buffer.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendForm​(MultiMap body, String charset)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJson​(Object body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendJsonObject​(JsonObject body)` | Like `HttpRequest.send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendMultipartForm​(MultipartForm body)` | Like `HttpRequest.send()` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `Future<HttpResponse<T>>` | HttpRequest.`sendStream​(ReadStream<Buffer> body)` | Like `HttpRequest.send()` but with an HTTP request `body` stream.
    `Future<HttpResponse<T>>` | HttpRequest.`sendStream​(Observable<Buffer> body)` | Like `HttpRequest.send()` but with an HTTP request `body` stream.
    `Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | WebClient.`updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

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

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

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

    Methods in io.vertx.rxjava.ext.web.handler that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SessionHandler.`flush​(RoutingContext ctx)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `Future<Void>` | SessionHandler.`flush​(RoutingContext ctx, boolean ignoreStatus)` | Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
    `Future<Void>` | SessionHandler.`setUser​(RoutingContext context, User user)` | Set the user for the session

    Method parameters in io.vertx.rxjava.ext.web.handler with type arguments of type Future
    Modifier and Type | Method | 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.
    `APIKeyHandler` | APIKeyHandler.`tokenExtractor​(java.util.function.Function<String,​Future<String>> tokenExtractor)` | Transform from user's token format to the AuthenticationHandler's format.

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

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

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

    Methods in io.vertx.rxjava.ext.web.handler.sockjs that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | SockJSSocket.`end()` | Call `SockJSSocket.close()`.
    `Future<Void>` | SockJSSocket.`end​(Buffer data)` | Same as `SockJSSocket.end(io.vertx.core.buffer.Buffer)` but writes some data to the stream before ending.
    `Future<Boolean>` | BridgeEvent.`future()` |
    `Future<Void>` | SockJSSocket.`pipeTo​(WriteStream<Buffer> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | SockJSSocket.`write​(Buffer data)` |
    `Future<Void>` | SockJSSocket.`write​(String data)` | Write a `String` to the socket, encoded in UTF-8.

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

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

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

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

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

    Methods in io.vertx.rxjava.grpc.client that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcClient.`close()` | Close this client.
    `Future<Void>` | GrpcClientRequest.`end()` | Ends the stream.
    `Future<Void>` | GrpcClientRequest.`end​(Req data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Resp>` | GrpcClientResponse.`last()` |
    `Future<Void>` | GrpcClientResponse.`pipeTo​(WriteStream<Resp> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request()` | Like `GrpcClient.request(io.vertx.core.net.Address)` with the default remote server.
    `Future<GrpcClientRequest<Buffer,​Buffer>>` | GrpcClient.`request​(Address server)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(Address server, ServiceMethod<Resp,​Req> method)` | Connect to the remote `server` and create a request for any hosted gRPC service.
    `<Req,​Resp> Future<GrpcClientRequest<Req,​Resp>>` | GrpcClient.`request​(ServiceMethod<Resp,​Req> method)` | Like `GrpcClient.request(io.vertx.core.net.Address)` with the default remote server.
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`response()` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(ReadStream<Req> body)` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(Req item)` |
    `Future<GrpcClientResponse<Req,​Resp>>` | GrpcClientRequest.`send​(Observable<Req> body)` |
    `Future<Void>` | GrpcClientRequest.`write​(Req data)` | Write some data to the stream.

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

    Methods in io.vertx.rxjava.grpc.common that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcReadStream.`end()` |
    `Future<Void>` | GrpcWriteStream.`end()` | Ends the stream.
    `Future<Void>` | GrpcWriteStream.`end​(T data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | GrpcWriteStream.`endMessage​(GrpcMessage message)` | End the stream with an encoded gRPC message.
    `Future<T>` | GrpcReadStream.`last()` |
    `Future<Void>` | GrpcReadStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | GrpcWriteStream.`write​(T data)` | Write some data to the stream.
    `Future<Void>` | GrpcWriteStream.`writeMessage​(GrpcMessage message)` | Write an encoded gRPC message.

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

    Methods in io.vertx.rxjava.grpc.server that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | GrpcServerResponse.`end()` | Ends the stream.
    `Future<Void>` | GrpcServerResponse.`end​(Resp data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Req>` | GrpcServerRequest.`last()` |
    `Future<Void>` | GrpcServerRequest.`pipeTo​(WriteStream<Req> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<Void>` | GrpcServerResponse.`send​(ReadStream<Resp> body)` |
    `Future<Void>` | GrpcServerResponse.`send​(Resp item)` |
    `Future<Void>` | GrpcServerResponse.`send​(Observable<Resp> body)` |
    `Future<Void>` | GrpcServerResponse.`write​(Resp data)` | Write some data to the stream.

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

    Methods in io.vertx.rxjava.jdbcclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Integer>` | JDBCConnection.`getTransactionIsolation()` |
    `Future<Void>` | JDBCConnection.`setTransactionIsolation​(int isolationLevel)` |

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

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

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

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

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

    Methods in io.vertx.rxjava.kafka.client.producer that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | KafkaProducer.`abortTransaction()` | Aborts the ongoing transaction.
    `Future<Void>` | KafkaProducer.`beginTransaction()` | Starts a new kafka transaction.
    `Future<Void>` | KafkaProducer.`close()` | Close the producer
    `Future<Void>` | KafkaProducer.`close​(long timeout)` | Close the producer
    `Future<Void>` | KafkaProducer.`commitTransaction()` | Commits the ongoing transaction.
    `Future<Void>` | KafkaProducer.`end()` | Ends the stream.
    `Future<Void>` | KafkaProducer.`end​(KafkaProducerRecord<K,​V> data)` | Same as `WriteStream.end()` but writes some data to the stream before ending.
    `Future<Void>` | KafkaProducer.`flush()` | Invoking this method makes all buffered records immediately available to write
    `Future<Void>` | KafkaProducer.`initTransactions()` | Initializes the underlying kafka transactional producer.
    `Future<List<PartitionInfo>>` | KafkaProducer.`partitionsFor​(String topic)` | Get the partition metadata for the give topic.
    `Future<RecordMetadata>` | KafkaProducer.`send​(KafkaProducerRecord<K,​V> record)` | Asynchronously write a record to a topic
    `Future<Void>` | KafkaProducer.`write​(KafkaProducerRecord<K,​V> data)` | Write some data to the stream.

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

    Methods in io.vertx.rxjava.mqtt that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MqttClient.`authenticationExchange​(MqttAuthenticationExchangeMessage message)` | It is used for Enhanced Authentication and is able to carry an authentication method and authentication data.
    `Future<Void>` | MqttServer.`close()` | Close the server.
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host)` | Connects to an MQTT server calling connectHandler after connection
    `Future<MqttConnAckMessage>` | MqttClient.`connect​(int port, String host, String serverName)` | Connects to an MQTT server calling connectHandler after connection
    `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, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT server
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)` | Sends the PUBLISH message to the remote MQTT client
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttEndpoint.`publish​(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties)` | Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Future<Integer>` | MqttClient.`subscribe​(String topic, int qos)` | Subscribes to the topic with a specified QoS level
    `Future<Integer>` | MqttClient.`subscribe​(Map<String,​Integer> topics)` | Subscribes to the topics with related QoS levels
    `Future<Integer>` | MqttClient.`unsubscribe​(String topic)` | Unsubscribe from receiving messages on given topic
    `Future<Integer>` | MqttClient.`unsubscribe​(List<String> topics)` | Unsubscribe from receiving messages on given list of topic

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

    Methods in io.vertx.rxjava.mssqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, MSSQLConnectOptions connectOptions)` | Create a connection to SQL Server with the given `connectOptions`.
    `static Future<MSSQLConnection>` | MSSQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MSSQLConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.mssqlclient.MSSQLConnectOptions)` with options built from `connectionUri`.

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

    Methods in io.vertx.rxjava.mysqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | MySQLConnection.`changeUser​(MySQLAuthOptions options)` | Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, MySQLConnectOptions connectOptions)` | Create a connection to MySQL server with the given `connectOptions`.
    `static Future<MySQLConnection>` | MySQLConnection.`connect​(Vertx vertx, String connectionUri)` | Like `MySQLConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions)` with options built from `connectionUri`.
    `Future<Void>` | MySQLConnection.`debug()` | Send a DEBUG command to dump debug information to the server's stdout.
    `Future<String>` | MySQLConnection.`getInternalStatistics()` | Send a STATISTICS command to get a human readable string of the server internal status.
    `Future<Void>` | MySQLConnection.`ping()` | Send a PING command to check if the server is alive.
    `Future<Void>` | MySQLConnection.`resetConnection()` | Send a RESET_CONNECTION command to reset the session state.
    `Future<Void>` | MySQLConnection.`setOption​(MySQLSetOption option)` | Send a SET_OPTION command to set options for the current connection.
    `Future<Void>` | MySQLConnection.`specifySchema​(String schemaName)` | Send a INIT_DB command to change the default schema of the connection.

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

    Methods in io.vertx.rxjava.oracleclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, OracleConnectOptions connectOptions)` | Create a connection to Oracle with the given `connectOptions`.
    `static Future<OracleConnection>` | OracleConnection.`connect​(Vertx vertx, String connectionUri)` | Like `OracleConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.oracleclient.OracleConnectOptions)` with options built from `connectionUri`.

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

    Methods in io.vertx.rxjava.pgclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgConnection.`cancelRequest()` | Send a request cancellation message to tell the server to cancel processing request in this connection.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx)` | Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions)` with options build from the environment variables.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, PgConnectOptions options)` | Connects to the database and returns the connection if that succeeds.
    `static Future<PgConnection>` | PgConnection.`connect​(Vertx vertx, String connectionUri)` | Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions)` with options build from `connectionUri`.

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

    Methods in io.vertx.rxjava.pgclient.pubsub that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | PgSubscriber.`close()` | Close the subscriber, the retry policy will not be invoked.
    `Future<Void>` | PgSubscriber.`connect()` | Connect the subscriber to Postgres.
    `Future<Void>` | PgChannel.`pipeTo​(WriteStream<String> dst)` | Pipe this `ReadStream` to the `WriteStream`.

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

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

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

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

    Method parameters in io.vertx.rxjava.redis.client with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Redis` | Redis.`createClusterClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisClusterConnectOptions>> connectOptions)` | Creates a new cluster Redis client.
    `static Redis` | Redis.`createReplicationClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisReplicationConnectOptions>> connectOptions)` | Creates a new replication Redis client.
    `static Redis` | Redis.`createSentinelClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisSentinelConnectOptions>> connectOptions)` | Creates a new sentinel Redis client.
    `static Redis` | Redis.`createStandaloneClient​(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)` | Creates a new standalone Redis client.

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

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

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

    Methods in io.vertx.rxjava.servicediscovery.spi that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Record>` | ServicePublisher.`publish​(Record record)` | Publishes a record.
    `Future<Void>` | ServicePublisher.`unpublish​(String id)` | Un-publishes a record.
    `Future<Record>` | ServicePublisher.`update​(Record record)` | Updates an existing record.

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

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

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

    Methods in io.vertx.rxjava.sqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Transaction>` | SqlConnection.`begin()` | Begin a transaction and returns a `Transaction` for controlling and tracking this transaction.
    `Future<Void>` | Cursor.`close()` | Release the cursor.
    `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()` | Close the client and release the associated resources.
    `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>` | PreparedQuery.`execute()` | Execute the query.
    `Future<T>` | PreparedQuery.`execute​(Tuple tuple)` | Execute the query.
    `Future<T>` | Query.`execute()` | Execute the query.
    `Future<T>` | PreparedQuery.`executeBatch​(List<Tuple> batch)` | Execute the query with a batch of tuples.
    `Future<SqlConnection>` | Pool.`getConnection()` | Get a connection from the pool.
    `Future<Void>` | RowStream.`pipeTo​(WriteStream<T> dst)` | Pipe this `ReadStream` to the `WriteStream`.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql)` | Create a prepared statement using the given `sql` string.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql, PrepareOptions options)` | Create a prepared statement using the given `sql` string.
    `Future<RowSet<Row>>` | Cursor.`read​(int count)` | Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `Future<Void>` | Transaction.`rollback()` | Rollback the transaction and release the associated resources.
    `<T> Future<T>` | Pool.`withConnection​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Get a connection from the pool and execute the given `function`.
    `<T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.rxjava.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.

    Method parameters in io.vertx.rxjava.sqlclient with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClientBuilder<C>` | ClientBuilder.`connectingTo​(java.util.function.Supplier<Future<SqlConnectOptions>> supplier)` | Configure the `database` the client should connect to.
    `<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​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.rxjava.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Single<T>` | Pool.`rxWithTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.
    `<T> Future<T>` | Pool.`withConnection​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Get a connection from the pool and execute the given `function`.
    `<T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(java.util.function.Function<io.vertx.rxjava.sqlclient.SqlConnection, io.vertx.core.Future<T>>)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `<T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | 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 | 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.servicediscovery

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

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

    Methods in io.vertx.servicediscovery.spi that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Record>` | ServicePublisher.`publish​(Record record)` | Publishes a record.
    `Future<Void>` | ServicePublisher.`unpublish​(String id)` | Un-publishes a record.
    `Future<Record>` | ServicePublisher.`update​(Record record)` | Updates an existing record.

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

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

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

    Methods in io.vertx.serviceproxy that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Message<JsonObject>>` | ServiceAuthInterceptor.`apply​(Message<JsonObject> msg)` | Deprecated.
    `static <T> Future<T>` | ServiceException.`fail​(int failureCode, String message)` | Create a failed Future containing a ServiceException.
    `static <T> Future<T>` | ServiceException.`fail​(int failureCode, String message, JsonObject debugInfo)` | Create a failed Future containing a ServiceException.
    `Future<Message<JsonObject>>` | ServiceInterceptor.`intercept​(Vertx vertx, Map<String,​Object> interceptorContext, Message<JsonObject> body)` | Perform the interceptor handling

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

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

    Methods in io.vertx.serviceresolver that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | ServiceResolverClient.`close()` | Close the client and release the resources.
    `Future<Endpoint>` | ServiceResolverClient.`resolveEndpoint​(ServiceAddress address)` |

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

    Methods in io.vertx.sqlclient that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Transaction>` | SqlConnection.`begin()` | Begin a transaction and returns a `Transaction` for controlling and tracking this transaction.
    `Future<Void>` | Cursor.`close()` | Release the cursor.
    `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()` | Close the client and release the associated resources.
    `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>` | PreparedQuery.`execute​(Tuple tuple)` | Execute the query.
    `Future<T>` | Query.`execute()` | Execute the query.
    `Future<T>` | PreparedQuery.`executeBatch​(List<Tuple> batch)` | Execute the query with a batch of tuples.
    `Future<SqlConnection>` | Pool.`getConnection()` | Get a connection from the pool.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql)` | Create a prepared statement using the given `sql` string.
    `Future<PreparedStatement>` | SqlConnection.`prepare​(String sql, PrepareOptions options)` | Create a prepared statement using the given `sql` string.
    `Future<RowSet<Row>>` | Cursor.`read​(int count)` | Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `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)` | Get a connection from the pool and execute the given `function`.
    `default <T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(Function)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `default <T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Execute the given `function` within a transaction.

    Method parameters in io.vertx.sqlclient with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClientBuilder<C>` | ClientBuilder.`connectingTo​(java.util.function.Supplier<Future<SqlConnectOptions>> supplier)` | Configure the `database` the client should connect to.
    `default <T> Future<T>` | Pool.`withConnection​(java.util.function.Function<SqlConnection,​Future<T>> function)` | Get a connection from the pool and execute the given `function`.
    `default <T> Future<T>` | Pool.`withTransaction​(TransactionPropagation txPropagation, java.util.function.Function<SqlConnection,​Future<T>> function)` | Like `Pool.withTransaction(Function)` but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
    `default <T> Future<T>` | Pool.`withTransaction​(java.util.function.Function<SqlConnection,​Future<T>> function)` | 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 | Description
    --- | --- | ---
    `Future<SqlConnection>` | ConnectionFactory.`connect​(Context context, C options)` | Create a connection using the given `context`.
    `default Future<SqlConnection>` | ConnectionFactory.`connect​(Context context, Future<C> fut)` |

    Methods in io.vertx.sqlclient.spi with parameters of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Future<SqlConnection>` | ConnectionFactory.`connect​(Context context, Future<C> fut)` |

    Method parameters in io.vertx.sqlclient.spi with type arguments of type Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Pool` | Driver.`createPool​(Vertx vertx, java.util.function.Supplier<Future<C>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler)` | Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`.
    `Pool` | Driver.`newPool​(Vertx vertx, java.util.function.Supplier<Future<C>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` | Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`.

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

    Methods in io.vertx.sqlclient.templates that return Future
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<R>` | SqlTemplate.`execute​(I params)` | Execute the query with the `parameters`
    `Future<R>` | SqlTemplate.`executeBatch​(List<I> batch)` | Execute a batch query with the `batch`.