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

- Packages that use Promise
  Package | Description
  --- | ---
  io.vertx.circuitbreaker |
  io.vertx.core |
  io.vertx.core.spi |
  io.vertx.core.spi.cluster |
  io.vertx.ext.bridge |
  io.vertx.ext.cluster.infinispan |
  io.vertx.ext.eventbus.bridge.tcp |
  io.vertx.ext.healthchecks |
  io.vertx.ext.httpservicefactory |
  io.vertx.ext.shell |
  io.vertx.ext.sync |
  io.vertx.ext.unit |
  io.vertx.ext.web.handler.graphql |
  io.vertx.ext.web.handler.graphql.dataloader |
  io.vertx.ext.web.handler.graphql.schema |
  io.vertx.lang.groovy |
  io.vertx.maven |
  io.vertx.rabbitmq |
  io.vertx.reactivex.core |
  io.vertx.rxjava.core |
  io.vertx.service |
  io.vertx.servicediscovery.consul |
  io.vertx.servicediscovery.docker |
  io.vertx.servicediscovery.kubernetes |
  io.vertx.servicediscovery.spi |
  io.vertx.spi.cluster.hazelcast |
  io.vertx.spi.cluster.ignite |
  io.vertx.spi.cluster.zookeeper |

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

    Methods in io.vertx.circuitbreaker with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.

    Method parameters in io.vertx.circuitbreaker with type arguments of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `default <T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using a callback.

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

    Methods in io.vertx.core that return Promise
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Promise<T>` | Promise.`promise()` Create a promise that hasn't completed yet

    Methods in io.vertx.core with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | Closeable.`close(Promise<Void> completion)` Close this resource, the `completion` promise must be notified when the operation has completed.
    `void` | Verticle.`start(Promise<Void> startPromise)` Start the verticle instance.
    `void` | AbstractVerticle.`start(Promise<Void> startPromise)` Start the verticle.
    `void` | Verticle.`stop(Promise<Void> stopPromise)` Stop the verticle instance.
    `void` | AbstractVerticle.`stop(Promise<Void> stopPromise)` Stop the verticle.

    Method parameters in io.vertx.core with type arguments of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Context.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
    `<T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Vertx.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
    `default <T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `<T> Future<T>` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `Context.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `<T> Future<T>` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `Vertx.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `<T> Future<T>` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.

  - ### Uses of Promise in io.vertx.core.spi

    Methods in io.vertx.core.spi with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | VerticleFactory.`createVerticle(String verticleName, ClassLoader classLoader, Promise<Callable<Verticle>> promise)` Create a verticle instance.

  - ### Uses of Promise in io.vertx.core.spi.cluster

    Methods in io.vertx.core.spi.cluster with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | ClusterManager.`addRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)` Share a new messaging handler registration with other nodes in the cluster.
    `<K,V> void` | ClusterManager.`getAsyncMap(String name, Promise<AsyncMap<K,V>> promise)` Return an `AsyncMap` for the given `name`.
    `void` | ClusterManager.`getCounter(String name, Promise<Counter> promise)` Return a `Counter` for the given `name`.
    `void` | ClusterManager.`getLockWithTimeout(String name, long timeout, Promise<Lock> promise)` Attempts to acquire a `Lock` for the given `name` within `timeout` milliseconds.
    `void` | ClusterManager.`getNodeInfo(String nodeId, Promise<NodeInfo> promise)` Get details about a specific node in the cluster.
    `void` | ClusterManager.`getRegistrations(String address, Promise<List<RegistrationInfo>> promise)` Get the messaging handler currently registered in the cluster.
    `void` | ClusterManager.`join(Promise<Void> promise)` Join the cluster.
    `void` | ClusterManager.`leave(Promise<Void> promise)` Leave the cluster.
    `void` | ClusterManager.`removeRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)` Signal removal of a messaging handler registration to other nodes in the cluster.
    `void` | NodeSelector.`selectForPublish(Message<?> message, Promise<Iterable<String>> promise)` Select a node for publishing the given `message`.
    `void` | NodeSelector.`selectForSend(Message<?> message, Promise<String> promise)` Select a node for sending the given `message`.
    `void` | ClusterManager.`setNodeInfo(NodeInfo nodeInfo, Promise<Void> promise)` Store the details about this clustered node.

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

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

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

    Methods in io.vertx.ext.cluster.infinispan with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | InfinispanClusterManager.`addRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `<K,V> void` | InfinispanClusterManager.`getAsyncMap(String name, Promise<AsyncMap<K,V>> promise)`
    `void` | InfinispanClusterManager.`getCounter(String name, Promise<Counter> promise)`
    `void` | InfinispanClusterManager.`getLockWithTimeout(String name, long timeout, Promise<Lock> promise)`
    `void` | InfinispanClusterManager.`getNodeInfo(String nodeId, Promise<NodeInfo> promise)`
    `void` | InfinispanClusterManager.`getRegistrations(String address, Promise<List<RegistrationInfo>> promise)`
    `void` | InfinispanClusterManager.`join(Promise<Void> promise)`
    `void` | InfinispanClusterManager.`leave(Promise<Void> promise)`
    `void` | InfinispanClusterManager.`removeRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `void` | InfinispanClusterManager.`setNodeInfo(NodeInfo nodeInfo, Promise<Void> promise)`

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

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

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

    Method parameters in io.vertx.ext.healthchecks with type arguments of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

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

    Methods in io.vertx.ext.httpservicefactory with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | HttpServiceFactory.`createVerticle(String verticleName, DeploymentOptions deploymentOptions, ClassLoader classLoader, Promise<Callable<Verticle>> promise)`

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

    Methods in io.vertx.ext.shell with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellVerticle.`start(Promise<Void> startFuture)`

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

    Methods in io.vertx.ext.sync with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | SyncVerticle.`start(Promise<Void> startFuture)` Deprecated.
    `void` | SyncVerticle.`stop(Promise<Void> stopFuture)` Deprecated.

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

    Methods in io.vertx.ext.unit with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | Completion.`resolve(Promise<T> future)` Completes the future upon completion, otherwise fails it.

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

    Subinterfaces of Promise in io.vertx.ext.web.handler.graphql
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApolloWSConnectionInitEvent`

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

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

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

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

  - ### Uses of Promise in io.vertx.lang.groovy

    Methods in io.vertx.lang.groovy with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | GroovyVerticleFactory.`createVerticle(String verticleName, ClassLoader classLoader, Promise<Callable<Verticle>> promise)`
    `void` | ScriptVerticle.`start(Promise<Void> startPromise)` Start the verticle instance.
    `void` | ScriptVerticle.`stop(Promise<Void> stopPromise)` Stop the verticle instance.

  - ### Uses of Promise in io.vertx.maven

    Methods in io.vertx.maven with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | MavenVerticleFactory.`createVerticle(String verticleName, DeploymentOptions deploymentOptions, ClassLoader classLoader, Promise<Callable<Verticle>> promise)`

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

    Method parameters in io.vertx.rabbitmq with type arguments of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)` Set a callback to be called whenever a new connection is established.

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

    Methods in io.vertx.reactivex.core that return Promise
    Modifier and Type | Method and Description
    --- | ---
    `Promise` | Promise.`getDelegate()`

    Methods in io.vertx.reactivex.core with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Promise<T>` | Promise.`newInstance(Promise arg)`
    `static <T> Promise<T>` | Promise.`newInstance(Promise arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `void` | AbstractVerticle.`start(Promise<Void> startFuture)`
    `void` | AbstractVerticle.`stop(Promise<Void> stopFuture)`

    Constructors in io.vertx.reactivex.core with parameters of type Promise
    Constructor and Description
    `Promise(Promise delegate)`

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

    Methods in io.vertx.rxjava.core that return Promise
    Modifier and Type | Method and Description
    --- | ---
    `Promise` | Promise.`getDelegate()`

    Methods in io.vertx.rxjava.core with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Promise<T>` | Promise.`newInstance(Promise arg)`
    `static <T> Promise<T>` | Promise.`newInstance(Promise arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `void` | AbstractVerticle.`start(Promise<Void> startFuture)`
    `void` | AbstractVerticle.`stop(Promise<Void> stopFuture)`

    Constructors in io.vertx.rxjava.core with parameters of type Promise
    Constructor and Description
    `Promise(Promise delegate)`

  - ### Uses of Promise in io.vertx.service

    Methods in io.vertx.service with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceVerticleFactory.`createVerticle(String verticleName, ClassLoader classLoader, Promise<Callable<Verticle>> promise)`
    `protected void` | ServiceVerticleFactory.`createVerticle(String verticleName, DeploymentOptions deploymentOptions, ClassLoader classLoader, Promise<Callable<Verticle>> promise)`

  - ### Uses of Promise in io.vertx.servicediscovery.consul

    Methods in io.vertx.servicediscovery.consul with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `ImportedConsulService` | ImportedConsulService.`register(ServicePublisher publisher, Promise<ImportedConsulService> completion)` Registers the service and completes the given future when done.
    `void` | ConsulServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`
    `void` | ImportedConsulService.`unregister(ServicePublisher publiher, Promise<Void> completion)` Unregisters the service and completes the given future when done, if not `null`

  - ### Uses of Promise in io.vertx.servicediscovery.docker

    Methods in io.vertx.servicediscovery.docker with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | DockerLinksServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`

  - ### Uses of Promise in io.vertx.servicediscovery.kubernetes

    Methods in io.vertx.servicediscovery.kubernetes with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | KubernetesServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`

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

    Methods in io.vertx.servicediscovery.spi with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceExporter.`init(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> future)` Starts the exporter.
    `void` | ServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> future)` Starts the importer.

  - ### Uses of Promise in io.vertx.spi.cluster.hazelcast

    Methods in io.vertx.spi.cluster.hazelcast that return types with arguments of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<Promise<Status>>` | ClusterHealthCheck.`createProcedure(Vertx vertx)` Creates a ready-to-use Vert.x cluster `HealthChecks` procedure.

    Methods in io.vertx.spi.cluster.hazelcast with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | HazelcastClusterManager.`addRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `<K,V> void` | HazelcastClusterManager.`getAsyncMap(String name, Promise<AsyncMap<K,V>> promise)`
    `void` | HazelcastClusterManager.`getCounter(String name, Promise<Counter> promise)`
    `void` | HazelcastClusterManager.`getLockWithTimeout(String name, long timeout, Promise<Lock> promise)`
    `void` | HazelcastClusterManager.`getNodeInfo(String nodeId, Promise<NodeInfo> promise)`
    `void` | HazelcastClusterManager.`getRegistrations(String address, Promise<List<RegistrationInfo>> promise)`
    `void` | HazelcastClusterManager.`join(Promise<Void> promise)`
    `void` | HazelcastClusterManager.`leave(Promise<Void> promise)`
    `void` | HazelcastClusterManager.`removeRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `void` | HazelcastClusterManager.`setNodeInfo(NodeInfo nodeInfo, Promise<Void> promise)`

  - ### Uses of Promise in io.vertx.spi.cluster.ignite

    Methods in io.vertx.spi.cluster.ignite with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | IgniteClusterManager.`addRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `<K,V> void` | IgniteClusterManager.`getAsyncMap(String name, Promise<AsyncMap<K,V>> promise)`
    `void` | IgniteClusterManager.`getCounter(String name, Promise<Counter> promise)`
    `void` | IgniteClusterManager.`getLockWithTimeout(String name, long timeout, Promise<Lock> promise)`
    `void` | IgniteClusterManager.`getNodeInfo(String id, Promise<NodeInfo> promise)`
    `void` | IgniteClusterManager.`getRegistrations(String address, Promise<List<RegistrationInfo>> promise)`
    `void` | IgniteClusterManager.`join(Promise<Void> promise)`
    `void` | IgniteClusterManager.`leave(Promise<Void> promise)`
    `void` | IgniteClusterManager.`removeRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `void` | IgniteClusterManager.`setNodeInfo(NodeInfo nodeInfo, Promise<Void> promise)`

  - ### Uses of Promise in io.vertx.spi.cluster.zookeeper

    Methods in io.vertx.spi.cluster.zookeeper with parameters of type Promise
    Modifier and Type | Method and Description
    --- | ---
    `void` | ZookeeperClusterManager.`addRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `<K,V> void` | ZookeeperClusterManager.`getAsyncMap(String name, Promise<AsyncMap<K,V>> promise)`
    `void` | ZookeeperClusterManager.`getCounter(String name, Promise<Counter> promise)`
    `void` | ZookeeperClusterManager.`getLockWithTimeout(String name, long timeout, Promise<Lock> promise)`
    `void` | ZookeeperClusterManager.`getNodeInfo(String nodeId, Promise<NodeInfo> promise)`
    `void` | ZookeeperClusterManager.`getRegistrations(String address, Promise<List<RegistrationInfo>> promise)`
    `void` | ZookeeperClusterManager.`join(Promise<Void> promise)`
    `void` | ZookeeperClusterManager.`leave(Promise<Void> promise)`
    `void` | ZookeeperClusterManager.`removeRegistration(String address, RegistrationInfo registrationInfo, Promise<Void> promise)`
    `void` | ZookeeperClusterManager.`setNodeInfo(NodeInfo nodeInfo, Promise<Void> promise)`

Copyright © 2021 Eclipse. All rights reserved.