java.lang.Object
- io.vertx.mutiny.ext.consul.ConsulClient

```
public class ConsulClient
extends Object
```
A Vert.x service used to interact with Consul.
NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field Description

static TypeArg<ConsulClient> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

ConsulClient(io.vertx.ext.consul.ConsulClient delegate)

ConsulClient(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject>`	`agentInfo()`	Returns the configuration and member information of the local agent
`io.vertx.core.json.JsonObject`	`agentInfoAndAwait()`	Blocking variant of `agentInfo()`.
`ConsulClient`	`agentInfoAndForget()`	Variant of `agentInfo()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<String>>`	`catalogDatacenters()`	Return all the datacenters that are known by the Consul server
`List<String>`	`catalogDatacentersAndAwait()`	Blocking variant of `catalogDatacenters()`.
`ConsulClient`	`catalogDatacentersAndForget()`	Variant of `catalogDatacenters()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList>`	`catalogNodes()`	Returns the nodes registered in a datacenter
`io.vertx.ext.consul.NodeList`	`catalogNodesAndAwait()`	Blocking variant of `catalogNodes()`.
`ConsulClient`	`catalogNodesAndForget()`	Variant of `catalogNodes()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogNodeServices(String node)`	Returns the node's registered services
`io.vertx.ext.consul.ServiceList`	`catalogNodeServicesAndAwait(String node)`	Blocking variant of `catalogNodeServices(String)`.
`ConsulClient`	`catalogNodeServicesAndForget(String node)`	Variant of `catalogNodeServices(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogNodeServicesWithOptions(String node, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the node's registered services This is blocking query unlike `catalogNodeServices(java.lang.String)`
`io.vertx.ext.consul.ServiceList`	`catalogNodeServicesWithOptionsAndAwait(String node, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `catalogNodeServicesWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`catalogNodeServicesWithOptionsAndForget(String node, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `catalogNodeServicesWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList>`	`catalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options)`	Returns the nodes registered in a datacenter
`io.vertx.ext.consul.NodeList`	`catalogNodesWithOptionsAndAwait(io.vertx.ext.consul.NodeQueryOptions options)`	Blocking variant of `catalogNodesWithOptions(NodeQueryOptions)`.
`ConsulClient`	`catalogNodesWithOptionsAndForget(io.vertx.ext.consul.NodeQueryOptions options)`	Variant of `catalogNodesWithOptions(NodeQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogServiceNodes(String service)`	Returns the nodes providing a service
`io.vertx.ext.consul.ServiceList`	`catalogServiceNodesAndAwait(String service)`	Blocking variant of `catalogServiceNodes(String)`.
`ConsulClient`	`catalogServiceNodesAndForget(String service)`	Variant of `catalogServiceNodes(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogServiceNodesWithOptions(String service, io.vertx.ext.consul.ServiceQueryOptions options)`	Returns the nodes providing a service
`io.vertx.ext.consul.ServiceList`	`catalogServiceNodesWithOptionsAndAwait(String service, io.vertx.ext.consul.ServiceQueryOptions options)`	Blocking variant of `catalogServiceNodesWithOptions(String,ServiceQueryOptions)`.
`ConsulClient`	`catalogServiceNodesWithOptionsAndForget(String service, io.vertx.ext.consul.ServiceQueryOptions options)`	Variant of `catalogServiceNodesWithOptions(String,ServiceQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogServices()`	Returns the services registered in a datacenter
`io.vertx.ext.consul.ServiceList`	`catalogServicesAndAwait()`	Blocking variant of `catalogServices()`.
`ConsulClient`	`catalogServicesAndForget()`	Variant of `catalogServices()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList>`	`catalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the services registered in a datacenter This is blocking query unlike `catalogServices()`
`io.vertx.ext.consul.ServiceList`	`catalogServicesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `catalogServicesWithOptions(BlockingQueryOptions)`.
`ConsulClient`	`catalogServicesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `catalogServicesWithOptions(BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`cloneAclToken(String id)`	Clone Acl token
`String`	`cloneAclTokenAndAwait(String id)`	Blocking variant of `cloneAclToken(String)`.
`ConsulClient`	`cloneAclTokenAndForget(String id)`	Variant of `cloneAclToken(String)` that ignores the result of the operation.
`void`	`close()`
`io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.DcCoordinates>>`	`coordinateDatacenters()`	Returns the WAN network coordinates for all Consul servers, organized by DCs
`List<io.vertx.ext.consul.DcCoordinates>`	`coordinateDatacentersAndAwait()`	Blocking variant of `coordinateDatacenters()`.
`ConsulClient`	`coordinateDatacentersAndForget()`	Variant of `coordinateDatacenters()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList>`	`coordinateNodes()`	Returns the LAN network coordinates for all nodes in a given DC
`io.vertx.ext.consul.CoordinateList`	`coordinateNodesAndAwait()`	Blocking variant of `coordinateNodes()`.
`ConsulClient`	`coordinateNodesAndForget()`	Variant of `coordinateNodes()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList>`	`coordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `coordinateNodes()`
`io.vertx.ext.consul.CoordinateList`	`coordinateNodesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `coordinateNodesWithOptions(BlockingQueryOptions)`.
`ConsulClient`	`coordinateNodesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `coordinateNodesWithOptions(BlockingQueryOptions)` that ignores the result of the operation.
`static ConsulClient`	`create(Vertx vertx)`
`static ConsulClient`	`create(Vertx vertx, io.vertx.ext.consul.ConsulClientOptions options)`
`io.smallrye.mutiny.Uni<String>`	`createAclToken(io.vertx.ext.consul.AclToken token)`	Create new Acl token
`String`	`createAclTokenAndAwait(io.vertx.ext.consul.AclToken token)`	Blocking variant of `createAclToken(AclToken)`.
`ConsulClient`	`createAclTokenAndForget(io.vertx.ext.consul.AclToken token)`	Variant of `createAclToken(AclToken)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`createPreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Unlike the bare Vert.x variant, this method returns a `Uni`.
`String`	`createPreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Blocking variant of `createPreparedQuery(PreparedQueryDefinition)`.
`ConsulClient`	`createPreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Variant of `createPreparedQuery(PreparedQueryDefinition)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`createSession()`	Initialize a new session
`String`	`createSessionAndAwait()`	Blocking variant of `createSession()`.
`ConsulClient`	`createSessionAndForget()`	Variant of `createSession()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`createSessionWithOptions(io.vertx.ext.consul.SessionOptions options)`	Initialize a new session
`String`	`createSessionWithOptionsAndAwait(io.vertx.ext.consul.SessionOptions options)`	Blocking variant of `createSessionWithOptions(SessionOptions)`.
`ConsulClient`	`createSessionWithOptionsAndForget(io.vertx.ext.consul.SessionOptions options)`	Variant of `createSessionWithOptions(SessionOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deletePreparedQuery(String id)`	Deletes an existing prepared query
`Void`	`deletePreparedQueryAndAwait(String id)`	Blocking variant of `deletePreparedQuery(String)`.
`ConsulClient`	`deletePreparedQueryAndForget(String id)`	Variant of `deletePreparedQuery(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deleteValue(String key)`	Remove the key/value pair that corresponding to the specified key
`Void`	`deleteValueAndAwait(String key)`	Blocking variant of `deleteValue(String)`.
`ConsulClient`	`deleteValueAndForget(String key)`	Variant of `deleteValue(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deleteValues(String keyPrefix)`	Removes all the key/value pair that corresponding to the specified key prefix
`Void`	`deleteValuesAndAwait(String keyPrefix)`	Blocking variant of `deleteValues(String)`.
`ConsulClient`	`deleteValuesAndForget(String keyPrefix)`	Variant of `deleteValues(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deregisterCatalogService(String nodeId, String serviceId)`	Deregister entities from the node or deregister the node itself.
`Void`	`deregisterCatalogServiceAndAwait(String nodeId, String serviceId)`	Blocking variant of `deregisterCatalogService(String,String)`.
`ConsulClient`	`deregisterCatalogServiceAndForget(String nodeId, String serviceId)`	Variant of `deregisterCatalogService(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deregisterCheck(String checkId)`	Remove a check from the local agent.
`Void`	`deregisterCheckAndAwait(String checkId)`	Blocking variant of `deregisterCheck(String)`.
`ConsulClient`	`deregisterCheckAndForget(String checkId)`	Variant of `deregisterCheck(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`deregisterService(String id)`	Remove a service from the local agent.
`Void`	`deregisterServiceAndAwait(String id)`	Blocking variant of `deregisterService(String)`.
`ConsulClient`	`deregisterServiceAndForget(String id)`	Variant of `deregisterService(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`destroyAclToken(String id)`	Destroy Acl token
`Void`	`destroyAclTokenAndAwait(String id)`	Blocking variant of `destroyAclToken(String)`.
`ConsulClient`	`destroyAclTokenAndForget(String id)`	Variant of `destroyAclToken(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`destroySession(String id)`	Destroys the given session
`Void`	`destroySessionAndAwait(String id)`	Blocking variant of `destroySession(String)`.
`ConsulClient`	`destroySessionAndForget(String id)`	Variant of `destroySession(String)` that ignores the result of the operation.
`boolean`	`equals(Object o)`
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse>`	`executePreparedQuery(String query)`	Executes an existing prepared query.
`io.vertx.ext.consul.PreparedQueryExecuteResponse`	`executePreparedQueryAndAwait(String query)`	Blocking variant of `executePreparedQuery(String)`.
`ConsulClient`	`executePreparedQueryAndForget(String query)`	Variant of `executePreparedQuery(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse>`	`executePreparedQueryWithOptions(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)`	Executes an existing prepared query.
`io.vertx.ext.consul.PreparedQueryExecuteResponse`	`executePreparedQueryWithOptionsAndAwait(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)`	Blocking variant of `executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions)`.
`ConsulClient`	`executePreparedQueryWithOptionsAndForget(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)`	Variant of `executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`failCheck(String checkId)`	Set status of the check to "critical".
`Void`	`failCheckAndAwait(String checkId)`	Blocking variant of `failCheck(String)`.
`ConsulClient`	`failCheckAndForget(String checkId)`	Variant of `failCheck(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`failCheckWithNote(String checkId, String note)`	Set status of the check to "critical".
`Void`	`failCheckWithNoteAndAwait(String checkId, String note)`	Blocking variant of `failCheckWithNote(String,String)`.
`ConsulClient`	`failCheckWithNoteAndForget(String checkId, String note)`	Variant of `failCheckWithNote(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event>`	`fireEvent(String name)`	Fires a new user event
`io.vertx.ext.consul.Event`	`fireEventAndAwait(String name)`	Blocking variant of `fireEvent(String)`.
`ConsulClient`	`fireEventAndForget(String name)`	Variant of `fireEvent(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event>`	`fireEventWithOptions(String name, io.vertx.ext.consul.EventOptions options)`	Fires a new user event
`io.vertx.ext.consul.Event`	`fireEventWithOptionsAndAwait(String name, io.vertx.ext.consul.EventOptions options)`	Blocking variant of `fireEventWithOptions(String,EventOptions)`.
`ConsulClient`	`fireEventWithOptionsAndForget(String name, io.vertx.ext.consul.EventOptions options)`	Variant of `fireEventWithOptions(String,EventOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.PreparedQueryDefinition>>`	`getAllPreparedQueries()`	Returns a list of all prepared queries.
`List<io.vertx.ext.consul.PreparedQueryDefinition>`	`getAllPreparedQueriesAndAwait()`	Blocking variant of `getAllPreparedQueries()`.
`ConsulClient`	`getAllPreparedQueriesAndForget()`	Variant of `getAllPreparedQueries()` that ignores the result of the operation.
`io.vertx.ext.consul.ConsulClient`	`getDelegate()`
`io.smallrye.mutiny.Uni<List<String>>`	`getKeys(String keyPrefix)`	Returns the list of keys that corresponding to the specified key prefix.
`List<String>`	`getKeysAndAwait(String keyPrefix)`	Blocking variant of `getKeys(String)`.
`ConsulClient`	`getKeysAndForget(String keyPrefix)`	Variant of `getKeys(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<String>>`	`getKeysWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the list of keys that corresponding to the specified key prefix.
`List<String>`	`getKeysWithOptionsAndAwait(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `getKeysWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`getKeysWithOptionsAndForget(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `getKeysWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryDefinition>`	`getPreparedQuery(String id)`	Returns an existing prepared query
`io.vertx.ext.consul.PreparedQueryDefinition`	`getPreparedQueryAndAwait(String id)`	Blocking variant of `getPreparedQuery(String)`.
`ConsulClient`	`getPreparedQueryAndForget(String id)`	Variant of `getPreparedQuery(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue>`	`getValue(String key)`	Returns key/value pair that corresponding to the specified key.
`io.vertx.ext.consul.KeyValue`	`getValueAndAwait(String key)`	Blocking variant of `getValue(String)`.
`ConsulClient`	`getValueAndForget(String key)`	Variant of `getValue(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList>`	`getValues(String keyPrefix)`	Returns the list of key/value pairs that corresponding to the specified key prefix.
`io.vertx.ext.consul.KeyValueList`	`getValuesAndAwait(String keyPrefix)`	Blocking variant of `getValues(String)`.
`ConsulClient`	`getValuesAndForget(String keyPrefix)`	Variant of `getValues(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList>`	`getValuesWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the list of key/value pairs that corresponding to the specified key prefix.
`io.vertx.ext.consul.KeyValueList`	`getValuesWithOptionsAndAwait(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `getValuesWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`getValuesWithOptionsAndForget(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `getValuesWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue>`	`getValueWithOptions(String key, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns key/value pair that corresponding to the specified key.
`io.vertx.ext.consul.KeyValue`	`getValueWithOptionsAndAwait(String key, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `getValueWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`getValueWithOptionsAndForget(String key, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `getValueWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`int`	`hashCode()`
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList>`	`healthChecks(String service)`	Returns the checks associated with the service
`io.vertx.ext.consul.CheckList`	`healthChecksAndAwait(String service)`	Blocking variant of `healthChecks(String)`.
`ConsulClient`	`healthChecksAndForget(String service)`	Variant of `healthChecks(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList>`	`healthChecksWithOptions(String service, io.vertx.ext.consul.CheckQueryOptions options)`	Returns the checks associated with the service
`io.vertx.ext.consul.CheckList`	`healthChecksWithOptionsAndAwait(String service, io.vertx.ext.consul.CheckQueryOptions options)`	Blocking variant of `healthChecksWithOptions(String,CheckQueryOptions)`.
`ConsulClient`	`healthChecksWithOptionsAndForget(String service, io.vertx.ext.consul.CheckQueryOptions options)`	Variant of `healthChecksWithOptions(String,CheckQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList>`	`healthServiceNodes(String service, boolean passing)`	Returns the nodes providing the service.
`io.vertx.ext.consul.ServiceEntryList`	`healthServiceNodesAndAwait(String service, boolean passing)`	Blocking variant of `healthServiceNodes(String,boolean)`.
`ConsulClient`	`healthServiceNodesAndForget(String service, boolean passing)`	Variant of `healthServiceNodes(String,boolean)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList>`	`healthServiceNodesWithOptions(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)`	Returns the nodes providing the service.
`io.vertx.ext.consul.ServiceEntryList`	`healthServiceNodesWithOptionsAndAwait(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)`	Blocking variant of `healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions)`.
`ConsulClient`	`healthServiceNodesWithOptionsAndForget(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)`	Variant of `healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList>`	`healthState(io.vertx.ext.consul.HealthState healthState)`	Returns the checks in the specified status
`io.vertx.ext.consul.CheckList`	`healthStateAndAwait(io.vertx.ext.consul.HealthState healthState)`	Blocking variant of `healthState(HealthState)`.
`ConsulClient`	`healthStateAndForget(io.vertx.ext.consul.HealthState healthState)`	Variant of `healthState(HealthState)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList>`	`healthStateWithOptions(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)`	Returns the checks in the specified status
`io.vertx.ext.consul.CheckList`	`healthStateWithOptionsAndAwait(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)`	Blocking variant of `healthStateWithOptions(HealthState,CheckQueryOptions)`.
`ConsulClient`	`healthStateWithOptionsAndForget(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)`	Variant of `healthStateWithOptions(HealthState,CheckQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.AclToken>`	`infoAclToken(String id)`	Get info of Acl token
`io.vertx.ext.consul.AclToken`	`infoAclTokenAndAwait(String id)`	Blocking variant of `infoAclToken(String)`.
`ConsulClient`	`infoAclTokenAndForget(String id)`	Variant of `infoAclToken(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session>`	`infoSession(String id)`	Returns the requested session information
`io.vertx.ext.consul.Session`	`infoSessionAndAwait(String id)`	Blocking variant of `infoSession(String)`.
`ConsulClient`	`infoSessionAndForget(String id)`	Variant of `infoSession(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session>`	`infoSessionWithOptions(String id, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the requested session information This is blocking query unlike `infoSession(java.lang.String)`
`io.vertx.ext.consul.Session`	`infoSessionWithOptionsAndAwait(String id, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `infoSessionWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`infoSessionWithOptionsAndForget(String id, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `infoSessionWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`leaderStatus()`	Get the Raft leader for the datacenter in which the agent is running.
`String`	`leaderStatusAndAwait()`	Blocking variant of `leaderStatus()`.
`ConsulClient`	`leaderStatusAndForget()`	Variant of `leaderStatus()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.AclToken>>`	`listAclTokens()`	Get list of Acl token
`List<io.vertx.ext.consul.AclToken>`	`listAclTokensAndAwait()`	Blocking variant of `listAclTokens()`.
`ConsulClient`	`listAclTokensAndForget()`	Variant of `listAclTokens()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList>`	`listEvents()`	Returns the most recent events known by the agent
`io.vertx.ext.consul.EventList`	`listEventsAndAwait()`	Blocking variant of `listEvents()`.
`ConsulClient`	`listEventsAndForget()`	Variant of `listEvents()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList>`	`listEventsWithOptions(io.vertx.ext.consul.EventListOptions options)`	Returns the most recent events known by the agent.
`io.vertx.ext.consul.EventList`	`listEventsWithOptionsAndAwait(io.vertx.ext.consul.EventListOptions options)`	Blocking variant of `listEventsWithOptions(EventListOptions)`.
`ConsulClient`	`listEventsWithOptionsAndForget(io.vertx.ext.consul.EventListOptions options)`	Variant of `listEventsWithOptions(EventListOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList>`	`listNodeSessions(String nodeId)`	Returns the active sessions for a given node
`io.vertx.ext.consul.SessionList`	`listNodeSessionsAndAwait(String nodeId)`	Blocking variant of `listNodeSessions(String)`.
`ConsulClient`	`listNodeSessionsAndForget(String nodeId)`	Variant of `listNodeSessions(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList>`	`listNodeSessionsWithOptions(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the active sessions for a given node This is blocking query unlike `listNodeSessions(java.lang.String)`
`io.vertx.ext.consul.SessionList`	`listNodeSessionsWithOptionsAndAwait(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `listNodeSessionsWithOptions(String,BlockingQueryOptions)`.
`ConsulClient`	`listNodeSessionsWithOptionsAndForget(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `listNodeSessionsWithOptions(String,BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList>`	`listSessions()`	Returns the active sessions
`io.vertx.ext.consul.SessionList`	`listSessionsAndAwait()`	Blocking variant of `listSessions()`.
`ConsulClient`	`listSessionsAndForget()`	Variant of `listSessions()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList>`	`listSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)`	Returns the active sessions This is blocking query unlike `listSessions()`
`io.vertx.ext.consul.SessionList`	`listSessionsWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)`	Blocking variant of `listSessionsWithOptions(BlockingQueryOptions)`.
`ConsulClient`	`listSessionsWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)`	Variant of `listSessionsWithOptions(BlockingQueryOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Check>>`	`localChecks()`	Return all the checks that are registered with the local agent.
`List<io.vertx.ext.consul.Check>`	`localChecksAndAwait()`	Blocking variant of `localChecks()`.
`ConsulClient`	`localChecksAndForget()`	Variant of `localChecks()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Service>>`	`localServices()`	Returns list of services registered with the local agent.
`List<io.vertx.ext.consul.Service>`	`localServicesAndAwait()`	Blocking variant of `localServices()`.
`ConsulClient`	`localServicesAndForget()`	Variant of `localServices()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`maintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)`	Places a given service into "maintenance mode"
`Void`	`maintenanceServiceAndAwait(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)`	Blocking variant of `maintenanceService(MaintenanceOptions)`.
`ConsulClient`	`maintenanceServiceAndForget(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)`	Variant of `maintenanceService(MaintenanceOptions)` that ignores the result of the operation.
`static ConsulClient`	`newInstance(io.vertx.ext.consul.ConsulClient arg)`
`io.smallrye.mutiny.Uni<Void>`	`passCheck(String checkId)`	Set status of the check to "passing".
`Void`	`passCheckAndAwait(String checkId)`	Blocking variant of `passCheck(String)`.
`ConsulClient`	`passCheckAndForget(String checkId)`	Variant of `passCheck(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`passCheckWithNote(String checkId, String note)`	Set status of the check to "passing".
`Void`	`passCheckWithNoteAndAwait(String checkId, String note)`	Blocking variant of `passCheckWithNote(String,String)`.
`ConsulClient`	`passCheckWithNoteAndForget(String checkId, String note)`	Variant of `passCheckWithNote(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<List<String>>`	`peersStatus()`	Retrieves the Raft peers for the datacenter in which the the agent is running.
`List<String>`	`peersStatusAndAwait()`	Blocking variant of `peersStatus()`.
`ConsulClient`	`peersStatusAndForget()`	Variant of `peersStatus()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Boolean>`	`putValue(String key, String value)`	Adds specified key/value pair
`Boolean`	`putValueAndAwait(String key, String value)`	Blocking variant of `putValue(String,String)`.
`ConsulClient`	`putValueAndForget(String key, String value)`	Variant of `putValue(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Boolean>`	`putValueWithOptions(String key, String value, io.vertx.ext.consul.KeyValueOptions options)`	Unlike the bare Vert.x variant, this method returns a `Uni`.
`Boolean`	`putValueWithOptionsAndAwait(String key, String value, io.vertx.ext.consul.KeyValueOptions options)`	Blocking variant of `putValueWithOptions(String,String,KeyValueOptions)`.
`ConsulClient`	`putValueWithOptionsAndForget(String key, String value, io.vertx.ext.consul.KeyValueOptions options)`	Variant of `putValueWithOptions(String,String,KeyValueOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`registerCatalogService(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)`	Register node with external service
`Void`	`registerCatalogServiceAndAwait(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)`	Blocking variant of `registerCatalogService(Node,ServiceOptions)`.
`ConsulClient`	`registerCatalogServiceAndForget(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)`	Variant of `registerCatalogService(Node,ServiceOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`registerCheck(io.vertx.ext.consul.CheckOptions checkOptions)`	Add a new check to the local agent.
`Void`	`registerCheckAndAwait(io.vertx.ext.consul.CheckOptions checkOptions)`	Blocking variant of `registerCheck(CheckOptions)`.
`ConsulClient`	`registerCheckAndForget(io.vertx.ext.consul.CheckOptions checkOptions)`	Variant of `registerCheck(CheckOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`registerService(io.vertx.ext.consul.ServiceOptions serviceOptions)`	Adds a new service, with an optional health check, to the local agent.
`Void`	`registerServiceAndAwait(io.vertx.ext.consul.ServiceOptions serviceOptions)`	Blocking variant of `registerService(ServiceOptions)`.
`ConsulClient`	`registerServiceAndForget(io.vertx.ext.consul.ServiceOptions serviceOptions)`	Variant of `registerService(ServiceOptions)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session>`	`renewSession(String id)`	Renews the given session.
`io.vertx.ext.consul.Session`	`renewSessionAndAwait(String id)`	Blocking variant of `renewSession(String)`.
`ConsulClient`	`renewSessionAndForget(String id)`	Variant of `renewSession(String)` that ignores the result of the operation.
`String`	`toString()`
`io.smallrye.mutiny.Uni<io.vertx.ext.consul.TxnResponse>`	`transaction(io.vertx.ext.consul.TxnRequest request)`	Manages multiple operations inside a single, atomic transaction.
`io.vertx.ext.consul.TxnResponse`	`transactionAndAwait(io.vertx.ext.consul.TxnRequest request)`	Blocking variant of `transaction(TxnRequest)`.
`ConsulClient`	`transactionAndForget(io.vertx.ext.consul.TxnRequest request)`	Variant of `transaction(TxnRequest)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<String>`	`updateAclToken(io.vertx.ext.consul.AclToken token)`	Update Acl token
`String`	`updateAclTokenAndAwait(io.vertx.ext.consul.AclToken token)`	Blocking variant of `updateAclToken(AclToken)`.
`ConsulClient`	`updateAclTokenAndForget(io.vertx.ext.consul.AclToken token)`	Variant of `updateAclToken(AclToken)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`updateCheck(String checkId, io.vertx.ext.consul.CheckStatus status)`	Set status of the check to given status.
`Void`	`updateCheckAndAwait(String checkId, io.vertx.ext.consul.CheckStatus status)`	Blocking variant of `updateCheck(String,CheckStatus)`.
`ConsulClient`	`updateCheckAndForget(String checkId, io.vertx.ext.consul.CheckStatus status)`	Variant of `updateCheck(String,CheckStatus)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`updateCheckWithNote(String checkId, io.vertx.ext.consul.CheckStatus status, String note)`	Set status of the check to given status.
`Void`	`updateCheckWithNoteAndAwait(String checkId, io.vertx.ext.consul.CheckStatus status, String note)`	Blocking variant of `updateCheckWithNote(String,CheckStatus,String)`.
`ConsulClient`	`updateCheckWithNoteAndForget(String checkId, io.vertx.ext.consul.CheckStatus status, String note)`	Variant of `updateCheckWithNote(String,CheckStatus,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`updatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Unlike the bare Vert.x variant, this method returns a `Uni`.
`Void`	`updatePreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Blocking variant of `updatePreparedQuery(PreparedQueryDefinition)`.
`ConsulClient`	`updatePreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)`	Variant of `updatePreparedQuery(PreparedQueryDefinition)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`warnCheck(String checkId)`	Set status of the check to "warning".
`Void`	`warnCheckAndAwait(String checkId)`	Blocking variant of `warnCheck(String)`.
`ConsulClient`	`warnCheckAndForget(String checkId)`	Variant of `warnCheck(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Void>`	`warnCheckWithNote(String checkId, String note)`	Set status of the check to "warning".
`Void`	`warnCheckWithNoteAndAwait(String checkId, String note)`	Blocking variant of `warnCheckWithNote(String,String)`.
`ConsulClient`	`warnCheckWithNoteAndForget(String checkId, String note)`	Variant of `warnCheckWithNote(String,String)` that ignores the result of the operation.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final TypeArg<ConsulClient> __TYPE_ARG
```
- Constructor Detail
  - ConsulClient
```
public ConsulClient(io.vertx.ext.consul.ConsulClient delegate)
```
  - ConsulClient
```
public ConsulClient(Object delegate)
```
- Method Detail
  - getDelegate
```
public io.vertx.ext.consul.ConsulClient getDelegate()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - create
```
public static ConsulClient create(Vertx vertx)
```
    Parameters:
    
    vertx - the Vert.x instance
    
    Returns:
    
    the client
  - create
```
public static ConsulClient create(Vertx vertx,
                                  io.vertx.ext.consul.ConsulClientOptions options)
```
    Parameters:
    
    vertx - the Vert.x instance
    
    options - the options
    
    Returns:
    
    the client
  - agentInfo
```
public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> agentInfo()
```
    Returns the configuration and member information of the local agent
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - agentInfoAndAwait
```
public io.vertx.core.json.JsonObject agentInfoAndAwait()
```
    Blocking variant of agentInfo().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the JsonObject instance produced by the operation.
  - agentInfoAndForget
```
public ConsulClient agentInfoAndForget()
```
    Variant of agentInfo() that ignores the result of the operation.
    This method subscribes on the result of agentInfo(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from agentInfo() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - coordinateNodes
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList> coordinateNodes()
```
    Returns the LAN network coordinates for all nodes in a given DC
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - coordinateNodesAndAwait
```
public io.vertx.ext.consul.CoordinateList coordinateNodesAndAwait()
```
    Blocking variant of coordinateNodes().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the CoordinateList instance produced by the operation.
  - coordinateNodesAndForget
```
public ConsulClient coordinateNodesAndForget()
```
    Variant of coordinateNodes() that ignores the result of the operation.
    This method subscribes on the result of coordinateNodes(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from coordinateNodes() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - coordinateNodesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList> coordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike coordinateNodes()
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - coordinateNodesWithOptionsAndAwait
```
public io.vertx.ext.consul.CoordinateList coordinateNodesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of coordinateNodesWithOptions(BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the CoordinateList instance produced by the operation.
  - coordinateNodesWithOptionsAndForget
```
public ConsulClient coordinateNodesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of coordinateNodesWithOptions(BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of coordinateNodesWithOptions(BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from coordinateNodesWithOptions(BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - coordinateDatacenters
```
public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.DcCoordinates>> coordinateDatacenters()
```
    Returns the WAN network coordinates for all Consul servers, organized by DCs
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - coordinateDatacentersAndAwait
```
public List<io.vertx.ext.consul.DcCoordinates> coordinateDatacentersAndAwait()
```
    Blocking variant of coordinateDatacenters().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - coordinateDatacentersAndForget
```
public ConsulClient coordinateDatacentersAndForget()
```
    Variant of coordinateDatacenters() that ignores the result of the operation.
    This method subscribes on the result of coordinateDatacenters(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from coordinateDatacenters() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getKeys
```
public io.smallrye.mutiny.Uni<List<String>> getKeys(String keyPrefix)
```
    Returns the list of keys that corresponding to the specified key prefix.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getKeysAndAwait
```
public List<String> getKeysAndAwait(String keyPrefix)
```
    Blocking variant of getKeys(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the List instance produced by the operation.
  - getKeysAndForget
```
public ConsulClient getKeysAndForget(String keyPrefix)
```
    Variant of getKeys(String) that ignores the result of the operation.
    This method subscribes on the result of getKeys(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getKeys(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getKeysWithOptions
```
public io.smallrye.mutiny.Uni<List<String>> getKeysWithOptions(String keyPrefix,
                                                               io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the list of keys that corresponding to the specified key prefix.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getKeysWithOptionsAndAwait
```
public List<String> getKeysWithOptionsAndAwait(String keyPrefix,
                                               io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of getKeysWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the List instance produced by the operation.
  - getKeysWithOptionsAndForget
```
public ConsulClient getKeysWithOptionsAndForget(String keyPrefix,
                                                io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of getKeysWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of getKeysWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getKeysWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getValue
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue> getValue(String key)
```
    Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getValueAndAwait
```
public io.vertx.ext.consul.KeyValue getValueAndAwait(String key)
```
    Blocking variant of getValue(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the KeyValue instance produced by the operation.
  - getValueAndForget
```
public ConsulClient getValueAndForget(String key)
```
    Variant of getValue(String) that ignores the result of the operation.
    This method subscribes on the result of getValue(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getValue(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getValueWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue> getValueWithOptions(String key,
                                                                                io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found. This is blocking query unlike getValue(java.lang.String)
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    key - the key
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getValueWithOptionsAndAwait
```
public io.vertx.ext.consul.KeyValue getValueWithOptionsAndAwait(String key,
                                                                io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of getValueWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    key - the key
    
    options - the blocking options
    
    Returns:
    
    the KeyValue instance produced by the operation.
  - getValueWithOptionsAndForget
```
public ConsulClient getValueWithOptionsAndForget(String key,
                                                 io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of getValueWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of getValueWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getValueWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    key - the key
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deleteValue
```
public io.smallrye.mutiny.Uni<Void> deleteValue(String key)
```
    Remove the key/value pair that corresponding to the specified key
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deleteValueAndAwait
```
public Void deleteValueAndAwait(String key)
```
    Blocking variant of deleteValue(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the Void instance produced by the operation.
  - deleteValueAndForget
```
public ConsulClient deleteValueAndForget(String key)
```
    Variant of deleteValue(String) that ignores the result of the operation.
    This method subscribes on the result of deleteValue(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteValue(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getValues
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList> getValues(String keyPrefix)
```
    Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getValuesAndAwait
```
public io.vertx.ext.consul.KeyValueList getValuesAndAwait(String keyPrefix)
```
    Blocking variant of getValues(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the KeyValueList instance produced by the operation.
  - getValuesAndForget
```
public ConsulClient getValuesAndForget(String keyPrefix)
```
    Variant of getValues(String) that ignores the result of the operation.
    This method subscribes on the result of getValues(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getValues(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getValuesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList> getValuesWithOptions(String keyPrefix,
                                                                                     io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found. This is blocking query unlike getValues(java.lang.String)
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getValuesWithOptionsAndAwait
```
public io.vertx.ext.consul.KeyValueList getValuesWithOptionsAndAwait(String keyPrefix,
                                                                     io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of getValuesWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the KeyValueList instance produced by the operation.
  - getValuesWithOptionsAndForget
```
public ConsulClient getValuesWithOptionsAndForget(String keyPrefix,
                                                  io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of getValuesWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of getValuesWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getValuesWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    keyPrefix - the prefix
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deleteValues
```
public io.smallrye.mutiny.Uni<Void> deleteValues(String keyPrefix)
```
    Removes all the key/value pair that corresponding to the specified key prefix
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deleteValuesAndAwait
```
public Void deleteValuesAndAwait(String keyPrefix)
```
    Blocking variant of deleteValues(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the Void instance produced by the operation.
  - deleteValuesAndForget
```
public ConsulClient deleteValuesAndForget(String keyPrefix)
```
    Variant of deleteValues(String) that ignores the result of the operation.
    This method subscribes on the result of deleteValues(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteValues(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    keyPrefix - the prefix
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - putValue
```
public io.smallrye.mutiny.Uni<Boolean> putValue(String key,
                                                String value)
```
    Adds specified key/value pair
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - putValueAndAwait
```
public Boolean putValueAndAwait(String key,
                                String value)
```
    Blocking variant of putValue(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    the Boolean instance produced by the operation.
  - putValueAndForget
```
public ConsulClient putValueAndForget(String key,
                                      String value)
```
    Variant of putValue(String,String) that ignores the result of the operation.
    This method subscribes on the result of putValue(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from putValue(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - putValueWithOptions
```
public io.smallrye.mutiny.Uni<Boolean> putValueWithOptions(String key,
                                                           String value,
                                                           io.vertx.ext.consul.KeyValueOptions options)
```
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    key - the key
    
    value - the value
    
    options - options used to push pair
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - putValueWithOptionsAndAwait
```
public Boolean putValueWithOptionsAndAwait(String key,
                                           String value,
                                           io.vertx.ext.consul.KeyValueOptions options)
```
    Blocking variant of putValueWithOptions(String,String,KeyValueOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    key - the key
    
    value - the value
    
    options - options used to push pair
    
    Returns:
    
    the Boolean instance produced by the operation.
  - putValueWithOptionsAndForget
```
public ConsulClient putValueWithOptionsAndForget(String key,
                                                 String value,
                                                 io.vertx.ext.consul.KeyValueOptions options)
```
    Variant of putValueWithOptions(String,String,KeyValueOptions) that ignores the result of the operation.
    This method subscribes on the result of putValueWithOptions(String,String,KeyValueOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from putValueWithOptions(String,String,KeyValueOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    key - the key
    
    value - the value
    
    options - options used to push pair
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - transaction
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.TxnResponse> transaction(io.vertx.ext.consul.TxnRequest request)
```
    Manages multiple operations inside a single, atomic transaction.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    request - transaction request
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - transactionAndAwait
```
public io.vertx.ext.consul.TxnResponse transactionAndAwait(io.vertx.ext.consul.TxnRequest request)
```
    Blocking variant of transaction(TxnRequest).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    request - transaction request
    
    Returns:
    
    the TxnResponse instance produced by the operation.
  - transactionAndForget
```
public ConsulClient transactionAndForget(io.vertx.ext.consul.TxnRequest request)
```
    Variant of transaction(TxnRequest) that ignores the result of the operation.
    This method subscribes on the result of transaction(TxnRequest), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from transaction(TxnRequest) but you don't need to compose it with other operations.
    
    Parameters:
    
    request - transaction request
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - createAclToken
```
public io.smallrye.mutiny.Uni<String> createAclToken(io.vertx.ext.consul.AclToken token)
```
    Create new Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    token - properties of the token
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - createAclTokenAndAwait
```
public String createAclTokenAndAwait(io.vertx.ext.consul.AclToken token)
```
    Blocking variant of createAclToken(AclToken).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    token - properties of the token
    
    Returns:
    
    the String instance produced by the operation.
  - createAclTokenAndForget
```
public ConsulClient createAclTokenAndForget(io.vertx.ext.consul.AclToken token)
```
    Variant of createAclToken(AclToken) that ignores the result of the operation.
    This method subscribes on the result of createAclToken(AclToken), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createAclToken(AclToken) but you don't need to compose it with other operations.
    
    Parameters:
    
    token - properties of the token
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - updateAclToken
```
public io.smallrye.mutiny.Uni<String> updateAclToken(io.vertx.ext.consul.AclToken token)
```
    Update Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    token - properties of the token to be updated
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - updateAclTokenAndAwait
```
public String updateAclTokenAndAwait(io.vertx.ext.consul.AclToken token)
```
    Blocking variant of updateAclToken(AclToken).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    token - properties of the token to be updated
    
    Returns:
    
    the String instance produced by the operation.
  - updateAclTokenAndForget
```
public ConsulClient updateAclTokenAndForget(io.vertx.ext.consul.AclToken token)
```
    Variant of updateAclToken(AclToken) that ignores the result of the operation.
    This method subscribes on the result of updateAclToken(AclToken), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateAclToken(AclToken) but you don't need to compose it with other operations.
    
    Parameters:
    
    token - properties of the token to be updated
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - cloneAclToken
```
public io.smallrye.mutiny.Uni<String> cloneAclToken(String id)
```
    Clone Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of token to be cloned
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - cloneAclTokenAndAwait
```
public String cloneAclTokenAndAwait(String id)
```
    Blocking variant of cloneAclToken(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of token to be cloned
    
    Returns:
    
    the String instance produced by the operation.
  - cloneAclTokenAndForget
```
public ConsulClient cloneAclTokenAndForget(String id)
```
    Variant of cloneAclToken(String) that ignores the result of the operation.
    This method subscribes on the result of cloneAclToken(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cloneAclToken(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of token to be cloned
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listAclTokens
```
public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.AclToken>> listAclTokens()
```
    Get list of Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listAclTokensAndAwait
```
public List<io.vertx.ext.consul.AclToken> listAclTokensAndAwait()
```
    Blocking variant of listAclTokens().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - listAclTokensAndForget
```
public ConsulClient listAclTokensAndForget()
```
    Variant of listAclTokens() that ignores the result of the operation.
    This method subscribes on the result of listAclTokens(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listAclTokens() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - infoAclToken
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.AclToken> infoAclToken(String id)
```
    Get info of Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - infoAclTokenAndAwait
```
public io.vertx.ext.consul.AclToken infoAclTokenAndAwait(String id)
```
    Blocking variant of infoAclToken(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the AclToken instance produced by the operation.
  - infoAclTokenAndForget
```
public ConsulClient infoAclTokenAndForget(String id)
```
    Variant of infoAclToken(String) that ignores the result of the operation.
    This method subscribes on the result of infoAclToken(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from infoAclToken(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - destroyAclToken
```
public io.smallrye.mutiny.Uni<Void> destroyAclToken(String id)
```
    Destroy Acl token
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - destroyAclTokenAndAwait
```
public Void destroyAclTokenAndAwait(String id)
```
    Blocking variant of destroyAclToken(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the Void instance produced by the operation.
  - destroyAclTokenAndForget
```
public ConsulClient destroyAclTokenAndForget(String id)
```
    Variant of destroyAclToken(String) that ignores the result of the operation.
    This method subscribes on the result of destroyAclToken(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from destroyAclToken(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of token
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - fireEvent
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event> fireEvent(String name)
```
    Fires a new user event
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    name - name of event
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - fireEventAndAwait
```
public io.vertx.ext.consul.Event fireEventAndAwait(String name)
```
    Blocking variant of fireEvent(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    name - name of event
    
    Returns:
    
    the Event instance produced by the operation.
  - fireEventAndForget
```
public ConsulClient fireEventAndForget(String name)
```
    Variant of fireEvent(String) that ignores the result of the operation.
    This method subscribes on the result of fireEvent(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from fireEvent(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    name - name of event
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - fireEventWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event> fireEventWithOptions(String name,
                                                                              io.vertx.ext.consul.EventOptions options)
```
    Fires a new user event
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    name - name of event
    
    options - options used to create event
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - fireEventWithOptionsAndAwait
```
public io.vertx.ext.consul.Event fireEventWithOptionsAndAwait(String name,
                                                              io.vertx.ext.consul.EventOptions options)
```
    Blocking variant of fireEventWithOptions(String,EventOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    name - name of event
    
    options - options used to create event
    
    Returns:
    
    the Event instance produced by the operation.
  - fireEventWithOptionsAndForget
```
public ConsulClient fireEventWithOptionsAndForget(String name,
                                                  io.vertx.ext.consul.EventOptions options)
```
    Variant of fireEventWithOptions(String,EventOptions) that ignores the result of the operation.
    This method subscribes on the result of fireEventWithOptions(String,EventOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from fireEventWithOptions(String,EventOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    name - name of event
    
    options - options used to create event
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listEvents
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList> listEvents()
```
    Returns the most recent events known by the agent
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listEventsAndAwait
```
public io.vertx.ext.consul.EventList listEventsAndAwait()
```
    Blocking variant of listEvents().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the EventList instance produced by the operation.
  - listEventsAndForget
```
public ConsulClient listEventsAndForget()
```
    Variant of listEvents() that ignores the result of the operation.
    This method subscribes on the result of listEvents(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listEvents() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listEventsWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList> listEventsWithOptions(io.vertx.ext.consul.EventListOptions options)
```
    Returns the most recent events known by the agent. This is blocking query unlike listEvents(). However, the semantics of this endpoint are slightly different. Most blocking queries provide a monotonic index and block until a newer index is available. This can be supported as a consequence of the total ordering of the consensus protocol. With gossip, there is no ordering, and instead X-Consul-Index maps to the newest event that matches the query.
    In practice, this means the index is only useful when used against a single agent and has no meaning globally. Because Consul defines the index as being opaque, clients should not be expecting a natural ordering either.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listEventsWithOptionsAndAwait
```
public io.vertx.ext.consul.EventList listEventsWithOptionsAndAwait(io.vertx.ext.consul.EventListOptions options)
```
    Blocking variant of listEventsWithOptions(EventListOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the EventList instance produced by the operation.
  - listEventsWithOptionsAndForget
```
public ConsulClient listEventsWithOptionsAndForget(io.vertx.ext.consul.EventListOptions options)
```
    Variant of listEventsWithOptions(EventListOptions) that ignores the result of the operation.
    This method subscribes on the result of listEventsWithOptions(EventListOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listEventsWithOptions(EventListOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - registerService
```
public io.smallrye.mutiny.Uni<Void> registerService(io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Adds a new service, with an optional health check, to the local agent.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    serviceOptions - the options of new service
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - registerServiceAndAwait
```
public Void registerServiceAndAwait(io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Blocking variant of registerService(ServiceOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    serviceOptions - the options of new service
    
    Returns:
    
    the Void instance produced by the operation.
  - registerServiceAndForget
```
public ConsulClient registerServiceAndForget(io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Variant of registerService(ServiceOptions) that ignores the result of the operation.
    This method subscribes on the result of registerService(ServiceOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from registerService(ServiceOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    serviceOptions - the options of new service
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - maintenanceService
```
public io.smallrye.mutiny.Uni<Void> maintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
```
    Places a given service into "maintenance mode"
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    maintenanceOptions - the maintenance options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - maintenanceServiceAndAwait
```
public Void maintenanceServiceAndAwait(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
```
    Blocking variant of maintenanceService(MaintenanceOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    maintenanceOptions - the maintenance options
    
    Returns:
    
    the Void instance produced by the operation.
  - maintenanceServiceAndForget
```
public ConsulClient maintenanceServiceAndForget(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
```
    Variant of maintenanceService(MaintenanceOptions) that ignores the result of the operation.
    This method subscribes on the result of maintenanceService(MaintenanceOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from maintenanceService(MaintenanceOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    maintenanceOptions - the maintenance options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deregisterService
```
public io.smallrye.mutiny.Uni<Void> deregisterService(String id)
```
    Remove a service from the local agent. The agent will take care of deregistering the service with the Catalog. If there is an associated check, that is also deregistered.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of service
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deregisterServiceAndAwait
```
public Void deregisterServiceAndAwait(String id)
```
    Blocking variant of deregisterService(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of service
    
    Returns:
    
    the Void instance produced by the operation.
  - deregisterServiceAndForget
```
public ConsulClient deregisterServiceAndForget(String id)
```
    Variant of deregisterService(String) that ignores the result of the operation.
    This method subscribes on the result of deregisterService(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deregisterService(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of service
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogServiceNodes
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServiceNodes(String service)
```
    Returns the nodes providing a service
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - name of service
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogServiceNodesAndAwait
```
public io.vertx.ext.consul.ServiceList catalogServiceNodesAndAwait(String service)
```
    Blocking variant of catalogServiceNodes(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - name of service
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogServiceNodesAndForget
```
public ConsulClient catalogServiceNodesAndForget(String service)
```
    Variant of catalogServiceNodes(String) that ignores the result of the operation.
    This method subscribes on the result of catalogServiceNodes(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogServiceNodes(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - name of service
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogServiceNodesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServiceNodesWithOptions(String service,
                                                                                              io.vertx.ext.consul.ServiceQueryOptions options)
```
    Returns the nodes providing a service
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - name of service
    
    options - options used to request services
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogServiceNodesWithOptionsAndAwait
```
public io.vertx.ext.consul.ServiceList catalogServiceNodesWithOptionsAndAwait(String service,
                                                                              io.vertx.ext.consul.ServiceQueryOptions options)
```
    Blocking variant of catalogServiceNodesWithOptions(String,ServiceQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - name of service
    
    options - options used to request services
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogServiceNodesWithOptionsAndForget
```
public ConsulClient catalogServiceNodesWithOptionsAndForget(String service,
                                                            io.vertx.ext.consul.ServiceQueryOptions options)
```
    Variant of catalogServiceNodesWithOptions(String,ServiceQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of catalogServiceNodesWithOptions(String,ServiceQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogServiceNodesWithOptions(String,ServiceQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - name of service
    
    options - options used to request services
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogDatacenters
```
public io.smallrye.mutiny.Uni<List<String>> catalogDatacenters()
```
    Return all the datacenters that are known by the Consul server
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogDatacentersAndAwait
```
public List<String> catalogDatacentersAndAwait()
```
    Blocking variant of catalogDatacenters().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - catalogDatacentersAndForget
```
public ConsulClient catalogDatacentersAndForget()
```
    Variant of catalogDatacenters() that ignores the result of the operation.
    This method subscribes on the result of catalogDatacenters(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogDatacenters() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogNodes
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList> catalogNodes()
```
    Returns the nodes registered in a datacenter
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogNodesAndAwait
```
public io.vertx.ext.consul.NodeList catalogNodesAndAwait()
```
    Blocking variant of catalogNodes().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the NodeList instance produced by the operation.
  - catalogNodesAndForget
```
public ConsulClient catalogNodesAndForget()
```
    Variant of catalogNodes() that ignores the result of the operation.
    This method subscribes on the result of catalogNodes(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogNodes() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogNodesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList> catalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options)
```
    Returns the nodes registered in a datacenter
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - options used to request nodes
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogNodesWithOptionsAndAwait
```
public io.vertx.ext.consul.NodeList catalogNodesWithOptionsAndAwait(io.vertx.ext.consul.NodeQueryOptions options)
```
    Blocking variant of catalogNodesWithOptions(NodeQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - options used to request nodes
    
    Returns:
    
    the NodeList instance produced by the operation.
  - catalogNodesWithOptionsAndForget
```
public ConsulClient catalogNodesWithOptionsAndForget(io.vertx.ext.consul.NodeQueryOptions options)
```
    Variant of catalogNodesWithOptions(NodeQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of catalogNodesWithOptions(NodeQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogNodesWithOptions(NodeQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - options used to request nodes
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthChecks
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthChecks(String service)
```
    Returns the checks associated with the service
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - the service name
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthChecksAndAwait
```
public io.vertx.ext.consul.CheckList healthChecksAndAwait(String service)
```
    Blocking variant of healthChecks(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - the service name
    
    Returns:
    
    the CheckList instance produced by the operation.
  - healthChecksAndForget
```
public ConsulClient healthChecksAndForget(String service)
```
    Variant of healthChecks(String) that ignores the result of the operation.
    This method subscribes on the result of healthChecks(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthChecks(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - the service name
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthChecksWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthChecksWithOptions(String service,
                                                                                     io.vertx.ext.consul.CheckQueryOptions options)
```
    Returns the checks associated with the service
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - the service name
    
    options - options used to request checks
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthChecksWithOptionsAndAwait
```
public io.vertx.ext.consul.CheckList healthChecksWithOptionsAndAwait(String service,
                                                                     io.vertx.ext.consul.CheckQueryOptions options)
```
    Blocking variant of healthChecksWithOptions(String,CheckQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - the service name
    
    options - options used to request checks
    
    Returns:
    
    the CheckList instance produced by the operation.
  - healthChecksWithOptionsAndForget
```
public ConsulClient healthChecksWithOptionsAndForget(String service,
                                                     io.vertx.ext.consul.CheckQueryOptions options)
```
    Variant of healthChecksWithOptions(String,CheckQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of healthChecksWithOptions(String,CheckQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthChecksWithOptions(String,CheckQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - the service name
    
    options - options used to request checks
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthState
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthState(io.vertx.ext.consul.HealthState healthState)
```
    Returns the checks in the specified status
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    healthState - the health state
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthStateAndAwait
```
public io.vertx.ext.consul.CheckList healthStateAndAwait(io.vertx.ext.consul.HealthState healthState)
```
    Blocking variant of healthState(HealthState).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    healthState - the health state
    
    Returns:
    
    the CheckList instance produced by the operation.
  - healthStateAndForget
```
public ConsulClient healthStateAndForget(io.vertx.ext.consul.HealthState healthState)
```
    Variant of healthState(HealthState) that ignores the result of the operation.
    This method subscribes on the result of healthState(HealthState), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthState(HealthState) but you don't need to compose it with other operations.
    
    Parameters:
    
    healthState - the health state
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthStateWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthStateWithOptions(io.vertx.ext.consul.HealthState healthState,
                                                                                    io.vertx.ext.consul.CheckQueryOptions options)
```
    Returns the checks in the specified status
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    healthState - the health state
    
    options - options used to request checks
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthStateWithOptionsAndAwait
```
public io.vertx.ext.consul.CheckList healthStateWithOptionsAndAwait(io.vertx.ext.consul.HealthState healthState,
                                                                    io.vertx.ext.consul.CheckQueryOptions options)
```
    Blocking variant of healthStateWithOptions(HealthState,CheckQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    healthState - the health state
    
    options - options used to request checks
    
    Returns:
    
    the CheckList instance produced by the operation.
  - healthStateWithOptionsAndForget
```
public ConsulClient healthStateWithOptionsAndForget(io.vertx.ext.consul.HealthState healthState,
                                                    io.vertx.ext.consul.CheckQueryOptions options)
```
    Variant of healthStateWithOptions(HealthState,CheckQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of healthStateWithOptions(HealthState,CheckQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthStateWithOptions(HealthState,CheckQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    healthState - the health state
    
    options - options used to request checks
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthServiceNodes
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList> healthServiceNodes(String service,
                                                                                       boolean passing)
```
    Returns the nodes providing the service. This endpoint is very similar to the catalogServiceNodes(java.lang.String) endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthServiceNodesAndAwait
```
public io.vertx.ext.consul.ServiceEntryList healthServiceNodesAndAwait(String service,
                                                                       boolean passing)
```
    Blocking variant of healthServiceNodes(String,boolean).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    Returns:
    
    the ServiceEntryList instance produced by the operation.
  - healthServiceNodesAndForget
```
public ConsulClient healthServiceNodesAndForget(String service,
                                                boolean passing)
```
    Variant of healthServiceNodes(String,boolean) that ignores the result of the operation.
    This method subscribes on the result of healthServiceNodes(String,boolean), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthServiceNodes(String,boolean) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - healthServiceNodesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList> healthServiceNodesWithOptions(String service,
                                                                                                  boolean passing,
                                                                                                  io.vertx.ext.consul.ServiceQueryOptions options)
```
    Returns the nodes providing the service. This endpoint is very similar to the catalogServiceNodesWithOptions(java.lang.String, io.vertx.ext.consul.ServiceQueryOptions) endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    options - options used to request services
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - healthServiceNodesWithOptionsAndAwait
```
public io.vertx.ext.consul.ServiceEntryList healthServiceNodesWithOptionsAndAwait(String service,
                                                                                  boolean passing,
                                                                                  io.vertx.ext.consul.ServiceQueryOptions options)
```
    Blocking variant of healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    options - options used to request services
    
    Returns:
    
    the ServiceEntryList instance produced by the operation.
  - healthServiceNodesWithOptionsAndForget
```
public ConsulClient healthServiceNodesWithOptionsAndForget(String service,
                                                           boolean passing,
                                                           io.vertx.ext.consul.ServiceQueryOptions options)
```
    Variant of healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    service - the service name
    
    passing - if true, filter results to only nodes with all checks in the passing state
    
    options - options used to request services
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogServices
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServices()
```
    Returns the services registered in a datacenter
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogServicesAndAwait
```
public io.vertx.ext.consul.ServiceList catalogServicesAndAwait()
```
    Blocking variant of catalogServices().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogServicesAndForget
```
public ConsulClient catalogServicesAndForget()
```
    Variant of catalogServices() that ignores the result of the operation.
    This method subscribes on the result of catalogServices(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogServices() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogServicesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the services registered in a datacenter This is blocking query unlike catalogServices()
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogServicesWithOptionsAndAwait
```
public io.vertx.ext.consul.ServiceList catalogServicesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of catalogServicesWithOptions(BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogServicesWithOptionsAndForget
```
public ConsulClient catalogServicesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of catalogServicesWithOptions(BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of catalogServicesWithOptions(BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogServicesWithOptions(BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogNodeServices
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogNodeServices(String node)
```
    Returns the node's registered services
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    node - node name
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogNodeServicesAndAwait
```
public io.vertx.ext.consul.ServiceList catalogNodeServicesAndAwait(String node)
```
    Blocking variant of catalogNodeServices(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    node - node name
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogNodeServicesAndForget
```
public ConsulClient catalogNodeServicesAndForget(String node)
```
    Variant of catalogNodeServices(String) that ignores the result of the operation.
    This method subscribes on the result of catalogNodeServices(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogNodeServices(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    node - node name
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - catalogNodeServicesWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogNodeServicesWithOptions(String node,
                                                                                              io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the node's registered services This is blocking query unlike catalogNodeServices(java.lang.String)
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    node - node name
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - catalogNodeServicesWithOptionsAndAwait
```
public io.vertx.ext.consul.ServiceList catalogNodeServicesWithOptionsAndAwait(String node,
                                                                              io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of catalogNodeServicesWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    node - node name
    
    options - the blocking options
    
    Returns:
    
    the ServiceList instance produced by the operation.
  - catalogNodeServicesWithOptionsAndForget
```
public ConsulClient catalogNodeServicesWithOptionsAndForget(String node,
                                                            io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of catalogNodeServicesWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of catalogNodeServicesWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from catalogNodeServicesWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    node - node name
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - localServices
```
public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Service>> localServices()
```
    Returns list of services registered with the local agent.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - localServicesAndAwait
```
public List<io.vertx.ext.consul.Service> localServicesAndAwait()
```
    Blocking variant of localServices().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - localServicesAndForget
```
public ConsulClient localServicesAndForget()
```
    Variant of localServices() that ignores the result of the operation.
    This method subscribes on the result of localServices(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from localServices() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - localChecks
```
public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Check>> localChecks()
```
    Return all the checks that are registered with the local agent.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - localChecksAndAwait
```
public List<io.vertx.ext.consul.Check> localChecksAndAwait()
```
    Blocking variant of localChecks().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - localChecksAndForget
```
public ConsulClient localChecksAndForget()
```
    Variant of localChecks() that ignores the result of the operation.
    This method subscribes on the result of localChecks(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from localChecks() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - registerCheck
```
public io.smallrye.mutiny.Uni<Void> registerCheck(io.vertx.ext.consul.CheckOptions checkOptions)
```
    Add a new check to the local agent. The agent is responsible for managing the status of the check and keeping the Catalog in sync.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkOptions - options used to register new check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - registerCheckAndAwait
```
public Void registerCheckAndAwait(io.vertx.ext.consul.CheckOptions checkOptions)
```
    Blocking variant of registerCheck(CheckOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkOptions - options used to register new check
    
    Returns:
    
    the Void instance produced by the operation.
  - registerCheckAndForget
```
public ConsulClient registerCheckAndForget(io.vertx.ext.consul.CheckOptions checkOptions)
```
    Variant of registerCheck(CheckOptions) that ignores the result of the operation.
    This method subscribes on the result of registerCheck(CheckOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from registerCheck(CheckOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkOptions - options used to register new check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deregisterCheck
```
public io.smallrye.mutiny.Uni<Void> deregisterCheck(String checkId)
```
    Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deregisterCheckAndAwait
```
public Void deregisterCheckAndAwait(String checkId)
```
    Blocking variant of deregisterCheck(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the Void instance produced by the operation.
  - deregisterCheckAndForget
```
public ConsulClient deregisterCheckAndForget(String checkId)
```
    Variant of deregisterCheck(String) that ignores the result of the operation.
    This method subscribes on the result of deregisterCheck(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deregisterCheck(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - passCheck
```
public io.smallrye.mutiny.Uni<Void> passCheck(String checkId)
```
    Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - passCheckAndAwait
```
public Void passCheckAndAwait(String checkId)
```
    Blocking variant of passCheck(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the Void instance produced by the operation.
  - passCheckAndForget
```
public ConsulClient passCheckAndForget(String checkId)
```
    Variant of passCheck(String) that ignores the result of the operation.
    This method subscribes on the result of passCheck(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from passCheck(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - passCheckWithNote
```
public io.smallrye.mutiny.Uni<Void> passCheckWithNote(String checkId,
                                                      String note)
```
    Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - passCheckWithNoteAndAwait
```
public Void passCheckWithNoteAndAwait(String checkId,
                                      String note)
```
    Blocking variant of passCheckWithNote(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the Void instance produced by the operation.
  - passCheckWithNoteAndForget
```
public ConsulClient passCheckWithNoteAndForget(String checkId,
                                               String note)
```
    Variant of passCheckWithNote(String,String) that ignores the result of the operation.
    This method subscribes on the result of passCheckWithNote(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from passCheckWithNote(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - warnCheck
```
public io.smallrye.mutiny.Uni<Void> warnCheck(String checkId)
```
    Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - warnCheckAndAwait
```
public Void warnCheckAndAwait(String checkId)
```
    Blocking variant of warnCheck(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the Void instance produced by the operation.
  - warnCheckAndForget
```
public ConsulClient warnCheckAndForget(String checkId)
```
    Variant of warnCheck(String) that ignores the result of the operation.
    This method subscribes on the result of warnCheck(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from warnCheck(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - warnCheckWithNote
```
public io.smallrye.mutiny.Uni<Void> warnCheckWithNote(String checkId,
                                                      String note)
```
    Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - warnCheckWithNoteAndAwait
```
public Void warnCheckWithNoteAndAwait(String checkId,
                                      String note)
```
    Blocking variant of warnCheckWithNote(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the Void instance produced by the operation.
  - warnCheckWithNoteAndForget
```
public ConsulClient warnCheckWithNoteAndForget(String checkId,
                                               String note)
```
    Variant of warnCheckWithNote(String,String) that ignores the result of the operation.
    This method subscribes on the result of warnCheckWithNote(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from warnCheckWithNote(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - failCheck
```
public io.smallrye.mutiny.Uni<Void> failCheck(String checkId)
```
    Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - failCheckAndAwait
```
public Void failCheckAndAwait(String checkId)
```
    Blocking variant of failCheck(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the Void instance produced by the operation.
  - failCheckAndForget
```
public ConsulClient failCheckAndForget(String checkId)
```
    Variant of failCheck(String) that ignores the result of the operation.
    This method subscribes on the result of failCheck(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from failCheck(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - failCheckWithNote
```
public io.smallrye.mutiny.Uni<Void> failCheckWithNote(String checkId,
                                                      String note)
```
    Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - failCheckWithNoteAndAwait
```
public Void failCheckWithNoteAndAwait(String checkId,
                                      String note)
```
    Blocking variant of failCheckWithNote(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the Void instance produced by the operation.
  - failCheckWithNoteAndForget
```
public ConsulClient failCheckWithNoteAndForget(String checkId,
                                               String note)
```
    Variant of failCheckWithNote(String,String) that ignores the result of the operation.
    This method subscribes on the result of failCheckWithNote(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from failCheckWithNote(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - updateCheck
```
public io.smallrye.mutiny.Uni<Void> updateCheck(String checkId,
                                                io.vertx.ext.consul.CheckStatus status)
```
    Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - updateCheckAndAwait
```
public Void updateCheckAndAwait(String checkId,
                                io.vertx.ext.consul.CheckStatus status)
```
    Blocking variant of updateCheck(String,CheckStatus).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    Returns:
    
    the Void instance produced by the operation.
  - updateCheckAndForget
```
public ConsulClient updateCheckAndForget(String checkId,
                                         io.vertx.ext.consul.CheckStatus status)
```
    Variant of updateCheck(String,CheckStatus) that ignores the result of the operation.
    This method subscribes on the result of updateCheck(String,CheckStatus), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCheck(String,CheckStatus) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - updateCheckWithNote
```
public io.smallrye.mutiny.Uni<Void> updateCheckWithNote(String checkId,
                                                        io.vertx.ext.consul.CheckStatus status,
                                                        String note)
```
    Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - updateCheckWithNoteAndAwait
```
public Void updateCheckWithNoteAndAwait(String checkId,
                                        io.vertx.ext.consul.CheckStatus status,
                                        String note)
```
    Blocking variant of updateCheckWithNote(String,CheckStatus,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the Void instance produced by the operation.
  - updateCheckWithNoteAndForget
```
public ConsulClient updateCheckWithNoteAndForget(String checkId,
                                                 io.vertx.ext.consul.CheckStatus status,
                                                 String note)
```
    Variant of updateCheckWithNote(String,CheckStatus,String) that ignores the result of the operation.
    This method subscribes on the result of updateCheckWithNote(String,CheckStatus,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCheckWithNote(String,CheckStatus,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    checkId - the ID of check
    
    status - new status of check
    
    note - specifies a human-readable message. This will be passed through to the check's Output field.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - leaderStatus
```
public io.smallrye.mutiny.Uni<String> leaderStatus()
```
    Get the Raft leader for the datacenter in which the agent is running. It returns an address in format "10.1.10.12:8300"
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - leaderStatusAndAwait
```
public String leaderStatusAndAwait()
```
    Blocking variant of leaderStatus().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the String instance produced by the operation.
  - leaderStatusAndForget
```
public ConsulClient leaderStatusAndForget()
```
    Variant of leaderStatus() that ignores the result of the operation.
    This method subscribes on the result of leaderStatus(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from leaderStatus() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - peersStatus
```
public io.smallrye.mutiny.Uni<List<String>> peersStatus()
```
    Retrieves the Raft peers for the datacenter in which the the agent is running. It returns a list of addresses "10.1.10.12:8300", "10.1.10.13:8300"
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - peersStatusAndAwait
```
public List<String> peersStatusAndAwait()
```
    Blocking variant of peersStatus().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - peersStatusAndForget
```
public ConsulClient peersStatusAndForget()
```
    Variant of peersStatus() that ignores the result of the operation.
    This method subscribes on the result of peersStatus(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from peersStatus() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - createSession
```
public io.smallrye.mutiny.Uni<String> createSession()
```
    Initialize a new session
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - createSessionAndAwait
```
public String createSessionAndAwait()
```
    Blocking variant of createSession().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the String instance produced by the operation.
  - createSessionAndForget
```
public ConsulClient createSessionAndForget()
```
    Variant of createSession() that ignores the result of the operation.
    This method subscribes on the result of createSession(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createSession() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - createSessionWithOptions
```
public io.smallrye.mutiny.Uni<String> createSessionWithOptions(io.vertx.ext.consul.SessionOptions options)
```
    Initialize a new session
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - options used to create session
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - createSessionWithOptionsAndAwait
```
public String createSessionWithOptionsAndAwait(io.vertx.ext.consul.SessionOptions options)
```
    Blocking variant of createSessionWithOptions(SessionOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - options used to create session
    
    Returns:
    
    the String instance produced by the operation.
  - createSessionWithOptionsAndForget
```
public ConsulClient createSessionWithOptionsAndForget(io.vertx.ext.consul.SessionOptions options)
```
    Variant of createSessionWithOptions(SessionOptions) that ignores the result of the operation.
    This method subscribes on the result of createSessionWithOptions(SessionOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createSessionWithOptions(SessionOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - options used to create session
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - infoSession
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> infoSession(String id)
```
    Returns the requested session information
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of requested session
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - infoSessionAndAwait
```
public io.vertx.ext.consul.Session infoSessionAndAwait(String id)
```
    Blocking variant of infoSession(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of requested session
    
    Returns:
    
    the Session instance produced by the operation.
  - infoSessionAndForget
```
public ConsulClient infoSessionAndForget(String id)
```
    Variant of infoSession(String) that ignores the result of the operation.
    This method subscribes on the result of infoSession(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from infoSession(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of requested session
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - infoSessionWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> infoSessionWithOptions(String id,
                                                                                  io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the requested session information This is blocking query unlike infoSession(java.lang.String)
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of requested session
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - infoSessionWithOptionsAndAwait
```
public io.vertx.ext.consul.Session infoSessionWithOptionsAndAwait(String id,
                                                                  io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of infoSessionWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of requested session
    
    options - the blocking options
    
    Returns:
    
    the Session instance produced by the operation.
  - infoSessionWithOptionsAndForget
```
public ConsulClient infoSessionWithOptionsAndForget(String id,
                                                    io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of infoSessionWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of infoSessionWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from infoSessionWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of requested session
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - renewSession
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> renewSession(String id)
```
    Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of session that should be renewed
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - renewSessionAndAwait
```
public io.vertx.ext.consul.Session renewSessionAndAwait(String id)
```
    Blocking variant of renewSession(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of session that should be renewed
    
    Returns:
    
    the Session instance produced by the operation.
  - renewSessionAndForget
```
public ConsulClient renewSessionAndForget(String id)
```
    Variant of renewSession(String) that ignores the result of the operation.
    This method subscribes on the result of renewSession(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from renewSession(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of session that should be renewed
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listSessions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listSessions()
```
    Returns the active sessions
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listSessionsAndAwait
```
public io.vertx.ext.consul.SessionList listSessionsAndAwait()
```
    Blocking variant of listSessions().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the SessionList instance produced by the operation.
  - listSessionsAndForget
```
public ConsulClient listSessionsAndForget()
```
    Variant of listSessions() that ignores the result of the operation.
    This method subscribes on the result of listSessions(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listSessions() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listSessionsWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the active sessions This is blocking query unlike listSessions()
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listSessionsWithOptionsAndAwait
```
public io.vertx.ext.consul.SessionList listSessionsWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of listSessionsWithOptions(BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the SessionList instance produced by the operation.
  - listSessionsWithOptionsAndForget
```
public ConsulClient listSessionsWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of listSessionsWithOptions(BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of listSessionsWithOptions(BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listSessionsWithOptions(BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listNodeSessions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listNodeSessions(String nodeId)
```
    Returns the active sessions for a given node
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    nodeId - the ID of node
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listNodeSessionsAndAwait
```
public io.vertx.ext.consul.SessionList listNodeSessionsAndAwait(String nodeId)
```
    Blocking variant of listNodeSessions(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    nodeId - the ID of node
    
    Returns:
    
    the SessionList instance produced by the operation.
  - listNodeSessionsAndForget
```
public ConsulClient listNodeSessionsAndForget(String nodeId)
```
    Variant of listNodeSessions(String) that ignores the result of the operation.
    This method subscribes on the result of listNodeSessions(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listNodeSessions(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    nodeId - the ID of node
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - listNodeSessionsWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listNodeSessionsWithOptions(String nodeId,
                                                                                           io.vertx.ext.consul.BlockingQueryOptions options)
```
    Returns the active sessions for a given node This is blocking query unlike listNodeSessions(java.lang.String)
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    nodeId - the ID of node
    
    options - the blocking options
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - listNodeSessionsWithOptionsAndAwait
```
public io.vertx.ext.consul.SessionList listNodeSessionsWithOptionsAndAwait(String nodeId,
                                                                           io.vertx.ext.consul.BlockingQueryOptions options)
```
    Blocking variant of listNodeSessionsWithOptions(String,BlockingQueryOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    nodeId - the ID of node
    
    options - the blocking options
    
    Returns:
    
    the SessionList instance produced by the operation.
  - listNodeSessionsWithOptionsAndForget
```
public ConsulClient listNodeSessionsWithOptionsAndForget(String nodeId,
                                                         io.vertx.ext.consul.BlockingQueryOptions options)
```
    Variant of listNodeSessionsWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.
    This method subscribes on the result of listNodeSessionsWithOptions(String,BlockingQueryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listNodeSessionsWithOptions(String,BlockingQueryOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    nodeId - the ID of node
    
    options - the blocking options
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - destroySession
```
public io.smallrye.mutiny.Uni<Void> destroySession(String id)
```
    Destroys the given session
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the ID of session
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - destroySessionAndAwait
```
public Void destroySessionAndAwait(String id)
```
    Blocking variant of destroySession(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the ID of session
    
    Returns:
    
    the Void instance produced by the operation.
  - destroySessionAndForget
```
public ConsulClient destroySessionAndForget(String id)
```
    Variant of destroySession(String) that ignores the result of the operation.
    This method subscribes on the result of destroySession(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from destroySession(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the ID of session
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - createPreparedQuery
```
public io.smallrye.mutiny.Uni<String> createPreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - createPreparedQueryAndAwait
```
public String createPreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Blocking variant of createPreparedQuery(PreparedQueryDefinition).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the String instance produced by the operation.
  - createPreparedQueryAndForget
```
public ConsulClient createPreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Variant of createPreparedQuery(PreparedQueryDefinition) that ignores the result of the operation.
    This method subscribes on the result of createPreparedQuery(PreparedQueryDefinition), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createPreparedQuery(PreparedQueryDefinition) but you don't need to compose it with other operations.
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getPreparedQuery
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryDefinition> getPreparedQuery(String id)
```
    Returns an existing prepared query
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the id of the query to read
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getPreparedQueryAndAwait
```
public io.vertx.ext.consul.PreparedQueryDefinition getPreparedQueryAndAwait(String id)
```
    Blocking variant of getPreparedQuery(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the id of the query to read
    
    Returns:
    
    the PreparedQueryDefinition instance produced by the operation.
  - getPreparedQueryAndForget
```
public ConsulClient getPreparedQueryAndForget(String id)
```
    Variant of getPreparedQuery(String) that ignores the result of the operation.
    This method subscribes on the result of getPreparedQuery(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getPreparedQuery(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the id of the query to read
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - getAllPreparedQueries
```
public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.PreparedQueryDefinition>> getAllPreparedQueries()
```
    Returns a list of all prepared queries.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getAllPreparedQueriesAndAwait
```
public List<io.vertx.ext.consul.PreparedQueryDefinition> getAllPreparedQueriesAndAwait()
```
    Blocking variant of getAllPreparedQueries().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the List instance produced by the operation.
  - getAllPreparedQueriesAndForget
```
public ConsulClient getAllPreparedQueriesAndForget()
```
    Variant of getAllPreparedQueries() that ignores the result of the operation.
    This method subscribes on the result of getAllPreparedQueries(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getAllPreparedQueries() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - updatePreparedQuery
```
public io.smallrye.mutiny.Uni<Void> updatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - updatePreparedQueryAndAwait
```
public Void updatePreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Blocking variant of updatePreparedQuery(PreparedQueryDefinition).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the Void instance produced by the operation.
  - updatePreparedQueryAndForget
```
public ConsulClient updatePreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)
```
    Variant of updatePreparedQuery(PreparedQueryDefinition) that ignores the result of the operation.
    This method subscribes on the result of updatePreparedQuery(PreparedQueryDefinition), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updatePreparedQuery(PreparedQueryDefinition) but you don't need to compose it with other operations.
    
    Parameters:
    
    definition - definition of the prepare query
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deletePreparedQuery
```
public io.smallrye.mutiny.Uni<Void> deletePreparedQuery(String id)
```
    Deletes an existing prepared query
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    id - the id of the query to delete
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deletePreparedQueryAndAwait
```
public Void deletePreparedQueryAndAwait(String id)
```
    Blocking variant of deletePreparedQuery(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    id - the id of the query to delete
    
    Returns:
    
    the Void instance produced by the operation.
  - deletePreparedQueryAndForget
```
public ConsulClient deletePreparedQueryAndForget(String id)
```
    Variant of deletePreparedQuery(String) that ignores the result of the operation.
    This method subscribes on the result of deletePreparedQuery(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deletePreparedQuery(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    id - the id of the query to delete
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - executePreparedQuery
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse> executePreparedQuery(String query)
```
    Executes an existing prepared query.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - executePreparedQueryAndAwait
```
public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryAndAwait(String query)
```
    Blocking variant of executePreparedQuery(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    Returns:
    
    the PreparedQueryExecuteResponse instance produced by the operation.
  - executePreparedQueryAndForget
```
public ConsulClient executePreparedQueryAndForget(String query)
```
    Variant of executePreparedQuery(String) that ignores the result of the operation.
    This method subscribes on the result of executePreparedQuery(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from executePreparedQuery(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - executePreparedQueryWithOptions
```
public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse> executePreparedQueryWithOptions(String query,
                                                                                                                io.vertx.ext.consul.PreparedQueryExecuteOptions options)
```
    Executes an existing prepared query.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    options - the options used to execute prepared query
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - executePreparedQueryWithOptionsAndAwait
```
public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryWithOptionsAndAwait(String query,
                                                                                                io.vertx.ext.consul.PreparedQueryExecuteOptions options)
```
    Blocking variant of executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    options - the options used to execute prepared query
    
    Returns:
    
    the PreparedQueryExecuteResponse instance produced by the operation.
  - executePreparedQueryWithOptionsAndForget
```
public ConsulClient executePreparedQueryWithOptionsAndForget(String query,
                                                             io.vertx.ext.consul.PreparedQueryExecuteOptions options)
```
    Variant of executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions) that ignores the result of the operation.
    This method subscribes on the result of executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
    
    options - the options used to execute prepared query
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - registerCatalogService
```
public io.smallrye.mutiny.Uni<Void> registerCatalogService(io.vertx.ext.consul.Node nodeOptions,
                                                           io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Register node with external service
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    nodeOptions - the options of new node
    
    serviceOptions - the options of new service
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - registerCatalogServiceAndAwait
```
public Void registerCatalogServiceAndAwait(io.vertx.ext.consul.Node nodeOptions,
                                           io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Blocking variant of registerCatalogService(Node,ServiceOptions).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    nodeOptions - the options of new node
    
    serviceOptions - the options of new service
    
    Returns:
    
    the Void instance produced by the operation.
  - registerCatalogServiceAndForget
```
public ConsulClient registerCatalogServiceAndForget(io.vertx.ext.consul.Node nodeOptions,
                                                    io.vertx.ext.consul.ServiceOptions serviceOptions)
```
    Variant of registerCatalogService(Node,ServiceOptions) that ignores the result of the operation.
    This method subscribes on the result of registerCatalogService(Node,ServiceOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from registerCatalogService(Node,ServiceOptions) but you don't need to compose it with other operations.
    
    Parameters:
    
    nodeOptions - the options of new node
    
    serviceOptions - the options of new service
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - deregisterCatalogService
```
public io.smallrye.mutiny.Uni<Void> deregisterCatalogService(String nodeId,
                                                             String serviceId)
```
    Deregister entities from the node or deregister the node itself.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    nodeId - the ID of node
    
    serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - deregisterCatalogServiceAndAwait
```
public Void deregisterCatalogServiceAndAwait(String nodeId,
                                             String serviceId)
```
    Blocking variant of deregisterCatalogService(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    nodeId - the ID of node
    
    serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
    
    Returns:
    
    the Void instance produced by the operation.
  - deregisterCatalogServiceAndForget
```
public ConsulClient deregisterCatalogServiceAndForget(String nodeId,
                                                      String serviceId)
```
    Variant of deregisterCatalogService(String,String) that ignores the result of the operation.
    This method subscribes on the result of deregisterCatalogService(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deregisterCatalogService(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    nodeId - the ID of node
    
    serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
    
    Returns:
    
    the instance of ConsulClient to chain method calls.
  - close
```
public void close()
```
  - newInstance
```
public static ConsulClient newInstance(io.vertx.ext.consul.ConsulClient arg)
```

Constructor	Description
`ConsulClient(io.vertx.ext.consul.ConsulClient delegate)`
`ConsulClient(Object delegate)`

Class ConsulClient

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

ConsulClient

ConsulClient

Method Detail

getDelegate

toString

equals

hashCode

create

create

agentInfo

agentInfoAndAwait

agentInfoAndForget

coordinateNodes

coordinateNodesAndAwait

coordinateNodesAndForget

coordinateNodesWithOptions

coordinateNodesWithOptionsAndAwait

coordinateNodesWithOptionsAndForget

coordinateDatacenters

coordinateDatacentersAndAwait

coordinateDatacentersAndForget

getKeys

getKeysAndAwait

getKeysAndForget

getKeysWithOptions

getKeysWithOptionsAndAwait

getKeysWithOptionsAndForget

getValue

getValueAndAwait

getValueAndForget

getValueWithOptions

getValueWithOptionsAndAwait

getValueWithOptionsAndForget

deleteValue

deleteValueAndAwait

deleteValueAndForget

getValues

getValuesAndAwait

getValuesAndForget

getValuesWithOptions

getValuesWithOptionsAndAwait

getValuesWithOptionsAndForget

deleteValues

deleteValuesAndAwait

deleteValuesAndForget

putValue

putValueAndAwait

putValueAndForget

putValueWithOptions

putValueWithOptionsAndAwait

putValueWithOptionsAndForget

transaction

transactionAndAwait

transactionAndForget

createAclToken

createAclTokenAndAwait

createAclTokenAndForget

updateAclToken

updateAclTokenAndAwait

updateAclTokenAndForget

cloneAclToken

cloneAclTokenAndAwait

cloneAclTokenAndForget

listAclTokens

listAclTokensAndAwait

listAclTokensAndForget

infoAclToken

infoAclTokenAndAwait

infoAclTokenAndForget

destroyAclToken

destroyAclTokenAndAwait

destroyAclTokenAndForget