io.vertx.reactivex.ext.consul

## Class ConsulService

- java.lang.Object
- - io.vertx.reactivex.ext.consul.ConsulClient
  - - io.vertx.reactivex.ext.consul.ConsulService

-     public class ConsulService
      extends ConsulClient

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static <any>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ConsulService(io.vertx.ext.consul.ConsulService delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ConsulService` | `agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulService` | `catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulService` | `catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | `catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulService` | `catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulService` | `catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | `catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | `catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | `catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulService` | `catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulService` | `cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Clone Acl token
    `void` | `close()` Close the client and release its resources
    `ConsulService` | `coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulService` | `coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulService` | `coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `ConsulService` | `createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Create new Acl token
    `static ConsulService` | `createEventBusProxy(Vertx vertx, String address)` Create a proxy to a service that is deployed somewhere on the event bus
    `ConsulService` | `createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulService` | `createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | `createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | `deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulService` | `deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulService` | `deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulService` | `deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulService` | `deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulService` | `destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Destroy Acl token
    `ConsulService` | `destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `boolean` | `equals(Object o)`
    `ConsulService` | `executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | `executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | `failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | `failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | `fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | `fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | `getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `io.vertx.ext.consul.ConsulService` | `getDelegate()`
    `ConsulService` | `getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | `getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | `getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulService` | `getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulService` | `getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | `getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | `getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `int` | `hashCode()`
    `ConsulService` | `healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | `healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | `healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | `healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | `healthState(HealthState healthState, Handler<AsyncResult<CheckList>> handler)` Returns the checks in the specified status
    `ConsulService` | `healthStateWithOptions(HealthState healthState, CheckQueryOptions checkQueryOptions, Handler<AsyncResult<CheckList>> handler)` Returns the checks in the specified status
    `ConsulService` | `infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Get info of Acl token
    `ConsulService` | `infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulService` | `infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `ConsulService` | `leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulService` | `listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulService` | `listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulService` | `listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulService` | `listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulService` | `listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulService` | `listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulService` | `listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulService` | `localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulService` | `localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulService` | `maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `static ConsulService` | `newInstance(io.vertx.ext.consul.ConsulService arg)`
    `ConsulService` | `passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | `passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | `peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulService` | `putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulService` | `putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulService` | `registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulService` | `registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulService` | `renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `Single<JsonObject>` | `rxAgentInfo()` Returns the configuration and member information of the local agent
    `Single<List<String>>` | `rxCatalogDatacenters()` Return all the datacenters that are known by the Consul server
    `Single<NodeList>` | `rxCatalogNodes()` Returns the nodes registered in a datacenter
    `Single<ServiceList>` | `rxCatalogNodeServices(String node)` Returns the node's registered services
    `Single<ServiceList>` | `rxCatalogNodeServicesWithOptions(String node, BlockingQueryOptions options)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `Single<NodeList>` | `rxCatalogNodesWithOptions(NodeQueryOptions options)` Returns the nodes registered in a datacenter
    `Single<ServiceList>` | `rxCatalogServiceNodes(String service)` Returns the nodes providing a service
    `Single<ServiceList>` | `rxCatalogServiceNodesWithOptions(String service, ServiceQueryOptions options)` Returns the nodes providing a service
    `Single<ServiceList>` | `rxCatalogServices()` Returns the services registered in a datacenter
    `Single<ServiceList>` | `rxCatalogServicesWithOptions(BlockingQueryOptions options)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `Single<String>` | `rxCloneAclToken(String id)` Clone Acl token
    `Single<List<DcCoordinates>>` | `rxCoordinateDatacenters()` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `Single<CoordinateList>` | `rxCoordinateNodes()` Returns the LAN network coordinates for all nodes in a given DC
    `Single<CoordinateList>` | `rxCoordinateNodesWithOptions(BlockingQueryOptions options)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `Single<String>` | `rxCreateAclToken(AclToken token)` Create new Acl token
    `Single<String>` | `rxCreatePreparedQuery(PreparedQueryDefinition definition)`
    `Single<String>` | `rxCreateSession()` Initialize a new session
    `Single<String>` | `rxCreateSessionWithOptions(SessionOptions options)` Initialize a new session
    `Completable` | `rxDeletePreparedQuery(String id)` Deletes an existing prepared query
    `Completable` | `rxDeleteValue(String key)` Remove the key/value pair that corresponding to the specified key
    `Completable` | `rxDeleteValues(String keyPrefix)` Removes all the key/value pair that corresponding to the specified key prefix
    `Completable` | `rxDeregisterCheck(String checkId)` Remove a check from the local agent.
    `Completable` | `rxDeregisterService(String id)` Remove a service from the local agent.
    `Completable` | `rxDestroyAclToken(String id)` Destroy Acl token
    `Completable` | `rxDestroySession(String id)` Destroys the given session
    `Single<PreparedQueryExecuteResponse>` | `rxExecutePreparedQuery(String query)` Executes an existing prepared query.
    `Single<PreparedQueryExecuteResponse>` | `rxExecutePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options)` Executes an existing prepared query.
    `Completable` | `rxFailCheck(String checkId)` Set status of the check to "critical".
    `Completable` | `rxFailCheckWithNote(String checkId, String note)` Set status of the check to "critical".
    `Single<Event>` | `rxFireEvent(String name)` Fires a new user event
    `Single<Event>` | `rxFireEventWithOptions(String name, EventOptions options)` Fires a new user event
    `Single<List<PreparedQueryDefinition>>` | `rxGetAllPreparedQueries()` Returns a list of all prepared queries.
    `Single<List<String>>` | `rxGetKeys(String keyPrefix)` Returns the list of keys that corresponding to the specified key prefix.
    `Single<List<String>>` | `rxGetKeysWithOptions(String keyPrefix, BlockingQueryOptions options)` Returns the list of keys that corresponding to the specified key prefix.
    `Single<PreparedQueryDefinition>` | `rxGetPreparedQuery(String id)` Returns an existing prepared query
    `Single<KeyValue>` | `rxGetValue(String key)` Returns key/value pair that corresponding to the specified key.
    `Single<KeyValueList>` | `rxGetValues(String keyPrefix)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `Single<KeyValueList>` | `rxGetValuesWithOptions(String keyPrefix, BlockingQueryOptions options)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `Single<KeyValue>` | `rxGetValueWithOptions(String key, BlockingQueryOptions options)` Returns key/value pair that corresponding to the specified key.
    `Single<CheckList>` | `rxHealthChecks(String service)` Returns the checks associated with the service
    `Single<CheckList>` | `rxHealthChecksWithOptions(String service, CheckQueryOptions options)` Returns the checks associated with the service
    `Single<ServiceEntryList>` | `rxHealthServiceNodes(String service, boolean passing)` Returns the nodes providing the service.
    `Single<ServiceEntryList>` | `rxHealthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options)` Returns the nodes providing the service.
    `Single<CheckList>` | `rxHealthState(HealthState healthState)` Returns the checks in the specified status
    `Single<CheckList>` | `rxHealthStateWithOptions(HealthState healthState, CheckQueryOptions checkQueryOptions)` Returns the checks in the specified status
    `Single<AclToken>` | `rxInfoAclToken(String id)` Get info of Acl token
    `Single<Session>` | `rxInfoSession(String id)` Returns the requested session information
    `Single<Session>` | `rxInfoSessionWithOptions(String id, BlockingQueryOptions options)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `Single<String>` | `rxLeaderStatus()` Get the Raft leader for the datacenter in which the agent is running.
    `Single<List<AclToken>>` | `rxListAclTokens()` Get list of Acl token
    `Single<EventList>` | `rxListEvents()` Returns the most recent events known by the agent
    `Single<EventList>` | `rxListEventsWithOptions(EventListOptions options)` Returns the most recent events known by the agent.
    `Single<SessionList>` | `rxListNodeSessions(String nodeId)` Returns the active sessions for a given node
    `Single<SessionList>` | `rxListNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `Single<SessionList>` | `rxListSessions()` Returns the active sessions
    `Single<SessionList>` | `rxListSessionsWithOptions(BlockingQueryOptions options)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `Single<List<Check>>` | `rxLocalChecks()` Return all the checks that are registered with the local agent.
    `Single<List<Service>>` | `rxLocalServices()` Returns list of services registered with the local agent.
    `Completable` | `rxMaintenanceService(MaintenanceOptions maintenanceOptions)` Places a given service into "maintenance mode"
    `Completable` | `rxPassCheck(String checkId)` Set status of the check to "passing".
    `Completable` | `rxPassCheckWithNote(String checkId, String note)` Set status of the check to "passing".
    `Single<List<String>>` | `rxPeersStatus()` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `Single<Boolean>` | `rxPutValue(String key, String value)` Adds specified key/value pair
    `Single<Boolean>` | `rxPutValueWithOptions(String key, String value, KeyValueOptions options)`
    `Completable` | `rxRegisterCheck(CheckOptions checkOptions)` Add a new check to the local agent.
    `Completable` | `rxRegisterService(ServiceOptions serviceOptions)` Adds a new service, with an optional health check, to the local agent.
    `Single<Session>` | `rxRenewSession(String id)` Renews the given session.
    `Single<TxnResponse>` | `rxTransaction(TxnRequest request)` Manages multiple operations inside a single, atomic transaction.
    `Single<String>` | `rxUpdateAclToken(AclToken token)` Update Acl token
    `Completable` | `rxUpdateCheck(String checkId, CheckStatus status)` Set status of the check to given status.
    `Completable` | `rxUpdateCheckWithNote(String checkId, CheckStatus status, String note)` Set status of the check to given status.
    `Completable` | `rxUpdatePreparedQuery(PreparedQueryDefinition definition)`
    `Completable` | `rxWarnCheck(String checkId)` Set status of the check to "warning".
    `Completable` | `rxWarnCheckWithNote(String checkId, String note)` Set status of the check to "warning".
    `String` | `toString()`
    `ConsulService` | `transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulService` | `updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Update Acl token
    `ConsulService` | `updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | `updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | `updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulService` | `warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulService` | `warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".

    - ### Methods inherited from class io.vertx.reactivex.ext.consul.ConsulClient

      `create, create, newInstance`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final <any> __TYPE_ARG

  - ### Constructor Detail

    - #### ConsulService

          public ConsulService(io.vertx.ext.consul.ConsulService delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `ConsulClient`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `ConsulClient`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `ConsulClient`

    - #### getDelegate

          public io.vertx.ext.consul.ConsulService getDelegate()

      Overrides:
        `getDelegate` in class `ConsulClient`

    - #### createEventBusProxy

          public static ConsulService createEventBusProxy(Vertx vertx,
                                                          String address)

      Create a proxy to a service that is deployed somewhere on the event bus
      Parameters:
        `vertx` - the Vert.x instance
        `address` - the address the service is listening on on the event bus
      Returns:
        the service

    - #### agentInfo

          public ConsulService agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the configuration and member information of the local agent
      Overrides:
        `agentInfo` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with the configuration and member information of the local agent
      Returns:
        reference to this, for fluency

    - #### rxAgentInfo

          public Single<JsonObject> rxAgentInfo()

      Description copied from class: `ConsulClient`
      Returns the configuration and member information of the local agent
      Overrides:
        `rxAgentInfo` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### coordinateNodes

          public ConsulService coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the LAN network coordinates for all nodes in a given DC
      Overrides:
        `coordinateNodes` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with network coordinates of nodes in datacenter
      Returns:
        reference to this, for fluency

    - #### rxCoordinateNodes

          public Single<CoordinateList> rxCoordinateNodes()

      Description copied from class: `ConsulClient`
      Returns the LAN network coordinates for all nodes in a given DC
      Overrides:
        `rxCoordinateNodes` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### coordinateNodesWithOptions

          public ConsulService coordinateNodesWithOptions(BlockingQueryOptions options,
                                                          Handler<AsyncResult<CoordinateList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
      Overrides:
        `coordinateNodesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
        `resultHandler` - will be provided with network coordinates of nodes in datacenter
      Returns:
        reference to this, for fluency

    - #### rxCoordinateNodesWithOptions

          public Single<CoordinateList> rxCoordinateNodesWithOptions(BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
      Overrides:
        `rxCoordinateNodesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### coordinateDatacenters

          public ConsulService coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the WAN network coordinates for all Consul servers, organized by DCs
      Overrides:
        `coordinateDatacenters` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with network coordinates for all Consul servers
      Returns:
        reference to this, for fluency

    - #### rxCoordinateDatacenters

          public Single<List<DcCoordinates>> rxCoordinateDatacenters()

      Description copied from class: `ConsulClient`
      Returns the WAN network coordinates for all Consul servers, organized by DCs
      Overrides:
        `rxCoordinateDatacenters` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### getKeys

          public ConsulService getKeys(String keyPrefix,
                                       Handler<AsyncResult<List<String>>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the list of keys that corresponding to the specified key prefix.
      Overrides:
        `getKeys` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `resultHandler` - will be provided with keys list
      Returns:
        reference to this, for fluency

    - #### rxGetKeys

          public Single<List<String>> rxGetKeys(String keyPrefix)

      Description copied from class: `ConsulClient`
      Returns the list of keys that corresponding to the specified key prefix.
      Overrides:
        `rxGetKeys` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
      Returns:
        reference to this, for fluency

    - #### getKeysWithOptions

          public ConsulService getKeysWithOptions(String keyPrefix,
                                                  BlockingQueryOptions options,
                                                  Handler<AsyncResult<List<String>>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the list of keys that corresponding to the specified key prefix.
      Overrides:
        `getKeysWithOptions` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `options` - the blocking options
        `resultHandler` - will be provided with keys list
      Returns:
        reference to this, for fluency

    - #### rxGetKeysWithOptions

          public Single<List<String>> rxGetKeysWithOptions(String keyPrefix,
                                                           BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the list of keys that corresponding to the specified key prefix.
      Overrides:
        `rxGetKeysWithOptions` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### getValue

          public ConsulService getValue(String key,
                                        Handler<AsyncResult<KeyValue>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns key/value pair that corresponding to the specified key. An empty `KeyValue` object will be returned if no such key is found.
      Overrides:
        `getValue` in class `ConsulClient`
      Parameters:
        `key` - the key
        `resultHandler` - will be provided with key/value pair
      Returns:
        reference to this, for fluency

    - #### rxGetValue

          public Single<KeyValue> rxGetValue(String key)

      Description copied from class: `ConsulClient`
      Returns key/value pair that corresponding to the specified key. An empty `KeyValue` object will be returned if no such key is found.
      Overrides:
        `rxGetValue` in class `ConsulClient`
      Parameters:
        `key` - the key
      Returns:
        reference to this, for fluency

    - #### getValueWithOptions

          public ConsulService getValueWithOptions(String key,
                                                   BlockingQueryOptions options,
                                                   Handler<AsyncResult<KeyValue>> resultHandler)

      Description copied from class: `ConsulClient`
      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 `ConsulClient.getValue(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.KeyValue>>)`
      Overrides:
        `getValueWithOptions` in class `ConsulClient`
      Parameters:
        `key` - the key
        `options` - the blocking options
        `resultHandler` - will be provided with key/value pair
      Returns:
        reference to this, for fluency

    - #### rxGetValueWithOptions

          public Single<KeyValue> rxGetValueWithOptions(String key,
                                                        BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      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 `ConsulClient.getValue(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.KeyValue>>)`
      Overrides:
        `rxGetValueWithOptions` in class `ConsulClient`
      Parameters:
        `key` - the key
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### deleteValue

          public ConsulService deleteValue(String key,
                                           Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Remove the key/value pair that corresponding to the specified key
      Overrides:
        `deleteValue` in class `ConsulClient`
      Parameters:
        `key` - the key
        `resultHandler` - will be called on complete
      Returns:
        reference to this, for fluency

    - #### rxDeleteValue

          public Completable rxDeleteValue(String key)

      Description copied from class: `ConsulClient`
      Remove the key/value pair that corresponding to the specified key
      Overrides:
        `rxDeleteValue` in class `ConsulClient`
      Parameters:
        `key` - the key
      Returns:
        reference to this, for fluency

    - #### getValues

          public ConsulService getValues(String keyPrefix,
                                         Handler<AsyncResult<KeyValueList>> resultHandler)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `getValues` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `resultHandler` - will be provided with list of key/value pairs
      Returns:
        reference to this, for fluency

    - #### rxGetValues

          public Single<KeyValueList> rxGetValues(String keyPrefix)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `rxGetValues` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
      Returns:
        reference to this, for fluency

    - #### getValuesWithOptions

          public ConsulService getValuesWithOptions(String keyPrefix,
                                                    BlockingQueryOptions options,
                                                    Handler<AsyncResult<KeyValueList>> resultHandler)

      Description copied from class: `ConsulClient`
      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 `ConsulClient.getValues(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.KeyValueList>>)`
      Overrides:
        `getValuesWithOptions` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `options` - the blocking options
        `resultHandler` - will be provided with list of key/value pairs
      Returns:
        reference to this, for fluency

    - #### rxGetValuesWithOptions

          public Single<KeyValueList> rxGetValuesWithOptions(String keyPrefix,
                                                             BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      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 `ConsulClient.getValues(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.KeyValueList>>)`
      Overrides:
        `rxGetValuesWithOptions` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### deleteValues

          public ConsulService deleteValues(String keyPrefix,
                                            Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Removes all the key/value pair that corresponding to the specified key prefix
      Overrides:
        `deleteValues` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
        `resultHandler` - will be called on complete
      Returns:
        reference to this, for fluency

    - #### rxDeleteValues

          public Completable rxDeleteValues(String keyPrefix)

      Description copied from class: `ConsulClient`
      Removes all the key/value pair that corresponding to the specified key prefix
      Overrides:
        `rxDeleteValues` in class `ConsulClient`
      Parameters:
        `keyPrefix` - the prefix
      Returns:
        reference to this, for fluency

    - #### putValue

          public ConsulService putValue(String key,
                                        String value,
                                        Handler<AsyncResult<Boolean>> resultHandler)

      Description copied from class: `ConsulClient`
      Adds specified key/value pair
      Overrides:
        `putValue` in class `ConsulClient`
      Parameters:
        `key` - the key
        `value` - the value
        `resultHandler` - will be provided with success of operation
      Returns:
        reference to this, for fluency

    - #### rxPutValue

          public Single<Boolean> rxPutValue(String key,
                                            String value)

      Description copied from class: `ConsulClient`
      Adds specified key/value pair
      Overrides:
        `rxPutValue` in class `ConsulClient`
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        reference to this, for fluency

    - #### putValueWithOptions

          public ConsulService putValueWithOptions(String key,
                                                   String value,
                                                   KeyValueOptions options,
                                                   Handler<AsyncResult<Boolean>> resultHandler)

      Overrides:
        `putValueWithOptions` in class `ConsulClient`
      Parameters:
        `key` - the key
        `value` - the value
        `options` - options used to push pair
        `resultHandler` - will be provided with success of operation
      Returns:
        reference to this, for fluency

    - #### rxPutValueWithOptions

          public Single<Boolean> rxPutValueWithOptions(String key,
                                                       String value,
                                                       KeyValueOptions options)

      Overrides:
        `rxPutValueWithOptions` in class `ConsulClient`
      Parameters:
        `key` - the key
        `value` - the value
        `options` - options used to push pair
      Returns:
        reference to this, for fluency

    - #### transaction

          public ConsulService transaction(TxnRequest request,
                                           Handler<AsyncResult<TxnResponse>> resultHandler)

      Description copied from class: `ConsulClient`
      Manages multiple operations inside a single, atomic transaction.
      Overrides:
        `transaction` in class `ConsulClient`
      Parameters:
        `request` - transaction request
        `resultHandler` - will be provided with result of transaction
      Returns:
        reference to this, for fluency

    - #### rxTransaction

          public Single<TxnResponse> rxTransaction(TxnRequest request)

      Description copied from class: `ConsulClient`
      Manages multiple operations inside a single, atomic transaction.
      Overrides:
        `rxTransaction` in class `ConsulClient`
      Parameters:
        `request` - transaction request
      Returns:
        reference to this, for fluency

    - #### createAclToken

          public ConsulService createAclToken(AclToken token,
                                              Handler<AsyncResult<String>> idHandler)

      Description copied from class: `ConsulClient`
      Create new Acl token
      Overrides:
        `createAclToken` in class `ConsulClient`
      Parameters:
        `token` - properties of the token
        `idHandler` - will be provided with ID of created token
      Returns:
        reference to this, for fluency

    - #### rxCreateAclToken

          public Single<String> rxCreateAclToken(AclToken token)

      Description copied from class: `ConsulClient`
      Create new Acl token
      Overrides:
        `rxCreateAclToken` in class `ConsulClient`
      Parameters:
        `token` - properties of the token
      Returns:
        reference to this, for fluency

    - #### updateAclToken

          public ConsulService updateAclToken(AclToken token,
                                              Handler<AsyncResult<String>> idHandler)

      Description copied from class: `ConsulClient`
      Update Acl token
      Overrides:
        `updateAclToken` in class `ConsulClient`
      Parameters:
        `token` - properties of the token to be updated
        `idHandler` - will be provided with ID of updated
      Returns:
        reference to this, for fluency

    - #### rxUpdateAclToken

          public Single<String> rxUpdateAclToken(AclToken token)

      Description copied from class: `ConsulClient`
      Update Acl token
      Overrides:
        `rxUpdateAclToken` in class `ConsulClient`
      Parameters:
        `token` - properties of the token to be updated
      Returns:
        reference to this, for fluency

    - #### cloneAclToken

          public ConsulService cloneAclToken(String id,
                                             Handler<AsyncResult<String>> idHandler)

      Description copied from class: `ConsulClient`
      Clone Acl token
      Overrides:
        `cloneAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token to be cloned
        `idHandler` - will be provided with ID of cloned token
      Returns:
        reference to this, for fluency

    - #### rxCloneAclToken

          public Single<String> rxCloneAclToken(String id)

      Description copied from class: `ConsulClient`
      Clone Acl token
      Overrides:
        `rxCloneAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token to be cloned
      Returns:
        reference to this, for fluency

    - #### listAclTokens

          public ConsulService listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)

      Description copied from class: `ConsulClient`
      Get list of Acl token
      Overrides:
        `listAclTokens` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of tokens
      Returns:
        reference to this, for fluency

    - #### rxListAclTokens

          public Single<List<AclToken>> rxListAclTokens()

      Description copied from class: `ConsulClient`
      Get list of Acl token
      Overrides:
        `rxListAclTokens` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### infoAclToken

          public ConsulService infoAclToken(String id,
                                            Handler<AsyncResult<AclToken>> tokenHandler)

      Description copied from class: `ConsulClient`
      Get info of Acl token
      Overrides:
        `infoAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token
        `tokenHandler` - will be provided with token
      Returns:
        reference to this, for fluency

    - #### rxInfoAclToken

          public Single<AclToken> rxInfoAclToken(String id)

      Description copied from class: `ConsulClient`
      Get info of Acl token
      Overrides:
        `rxInfoAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token
      Returns:
        reference to this, for fluency

    - #### destroyAclToken

          public ConsulService destroyAclToken(String id,
                                               Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Destroy Acl token
      Overrides:
        `destroyAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token
        `resultHandler` - will be called on complete
      Returns:
        reference to this, for fluency

    - #### rxDestroyAclToken

          public Completable rxDestroyAclToken(String id)

      Description copied from class: `ConsulClient`
      Destroy Acl token
      Overrides:
        `rxDestroyAclToken` in class `ConsulClient`
      Parameters:
        `id` - the ID of token
      Returns:
        reference to this, for fluency

    - #### fireEvent

          public ConsulService fireEvent(String name,
                                         Handler<AsyncResult<Event>> resultHandler)

      Description copied from class: `ConsulClient`
      Fires a new user event
      Overrides:
        `fireEvent` in class `ConsulClient`
      Parameters:
        `name` - name of event
        `resultHandler` - will be provided with properties of event
      Returns:
        reference to this, for fluency

    - #### rxFireEvent

          public Single<Event> rxFireEvent(String name)

      Description copied from class: `ConsulClient`
      Fires a new user event
      Overrides:
        `rxFireEvent` in class `ConsulClient`
      Parameters:
        `name` - name of event
      Returns:
        reference to this, for fluency

    - #### fireEventWithOptions

          public ConsulService fireEventWithOptions(String name,
                                                    EventOptions options,
                                                    Handler<AsyncResult<Event>> resultHandler)

      Description copied from class: `ConsulClient`
      Fires a new user event
      Overrides:
        `fireEventWithOptions` in class `ConsulClient`
      Parameters:
        `name` - name of event
        `options` - options used to create event
        `resultHandler` - will be provided with properties of event
      Returns:
        reference to this, for fluency

    - #### rxFireEventWithOptions

          public Single<Event> rxFireEventWithOptions(String name,
                                                      EventOptions options)

      Description copied from class: `ConsulClient`
      Fires a new user event
      Overrides:
        `rxFireEventWithOptions` in class `ConsulClient`
      Parameters:
        `name` - name of event
        `options` - options used to create event
      Returns:
        reference to this, for fluency

    - #### listEvents

          public ConsulService listEvents(Handler<AsyncResult<EventList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the most recent events known by the agent
      Overrides:
        `listEvents` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of events
      Returns:
        reference to this, for fluency

    - #### rxListEvents

          public Single<EventList> rxListEvents()

      Description copied from class: `ConsulClient`
      Returns the most recent events known by the agent
      Overrides:
        `rxListEvents` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### listEventsWithOptions

          public ConsulService listEventsWithOptions(EventListOptions options,
                                                     Handler<AsyncResult<EventList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the most recent events known by the agent. This is blocking query unlike `ConsulClient.listEvents(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.EventList>>)`. 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.

      Overrides:
        `listEventsWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
        `resultHandler` - will be provided with list of events
      Returns:
        reference to this, for fluency

    - #### rxListEventsWithOptions

          public Single<EventList> rxListEventsWithOptions(EventListOptions options)

      Description copied from class: `ConsulClient`
      Returns the most recent events known by the agent. This is blocking query unlike `ConsulClient.listEvents(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.EventList>>)`. 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.

      Overrides:
        `rxListEventsWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### registerService

          public ConsulService registerService(ServiceOptions serviceOptions,
                                               Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Adds a new service, with an optional health check, to the local agent.
      Overrides:
        `registerService` in class `ConsulClient`
      Parameters:
        `serviceOptions` - the options of new service
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxRegisterService

          public Completable rxRegisterService(ServiceOptions serviceOptions)

      Description copied from class: `ConsulClient`
      Adds a new service, with an optional health check, to the local agent.
      Overrides:
        `rxRegisterService` in class `ConsulClient`
      Parameters:
        `serviceOptions` - the options of new service
      Returns:
        reference to this, for fluency

    - #### maintenanceService

          public ConsulService maintenanceService(MaintenanceOptions maintenanceOptions,
                                                  Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Places a given service into "maintenance mode"
      Overrides:
        `maintenanceService` in class `ConsulClient`
      Parameters:
        `maintenanceOptions` - the maintenance options
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxMaintenanceService

          public Completable rxMaintenanceService(MaintenanceOptions maintenanceOptions)

      Description copied from class: `ConsulClient`
      Places a given service into "maintenance mode"
      Overrides:
        `rxMaintenanceService` in class `ConsulClient`
      Parameters:
        `maintenanceOptions` - the maintenance options
      Returns:
        reference to this, for fluency

    - #### deregisterService

          public ConsulService deregisterService(String id,
                                                 Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `deregisterService` in class `ConsulClient`
      Parameters:
        `id` - the ID of service
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxDeregisterService

          public Completable rxDeregisterService(String id)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `rxDeregisterService` in class `ConsulClient`
      Parameters:
        `id` - the ID of service
      Returns:
        reference to this, for fluency

    - #### healthChecks

          public ConsulService healthChecks(String service,
                                            Handler<AsyncResult<CheckList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the checks associated with the service
      Overrides:
        `healthChecks` in class `ConsulClient`
      Parameters:
        `service` - the service name
        `resultHandler` - will be provided with list of checks
      Returns:
        reference to this, for fluency

    - #### rxHealthChecks

          public Single<CheckList> rxHealthChecks(String service)

      Description copied from class: `ConsulClient`
      Returns the checks associated with the service
      Overrides:
        `rxHealthChecks` in class `ConsulClient`
      Parameters:
        `service` - the service name
      Returns:
        reference to this, for fluency

    - #### healthChecksWithOptions

          public ConsulService healthChecksWithOptions(String service,
                                                       CheckQueryOptions options,
                                                       Handler<AsyncResult<CheckList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the checks associated with the service
      Overrides:
        `healthChecksWithOptions` in class `ConsulClient`
      Parameters:
        `service` - the service name
        `options` - options used to request checks
        `resultHandler` - will be provided with list of checks
      Returns:
        reference to this, for fluency

    - #### rxHealthChecksWithOptions

          public Single<CheckList> rxHealthChecksWithOptions(String service,
                                                             CheckQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the checks associated with the service
      Overrides:
        `rxHealthChecksWithOptions` in class `ConsulClient`
      Parameters:
        `service` - the service name
        `options` - options used to request checks
      Returns:
        reference to this, for fluency

    - #### healthState

          public ConsulService healthState(HealthState healthState,
                                           Handler<AsyncResult<CheckList>> handler)

      Description copied from class: `ConsulClient`
      Returns the checks in the specified status
      Overrides:
        `healthState` in class `ConsulClient`
      Parameters:
        `healthState` - the health state
        `handler` - will be provided with list of checks
      Returns:
        reference to this, for fluency

    - #### rxHealthState

          public Single<CheckList> rxHealthState(HealthState healthState)

      Description copied from class: `ConsulClient`
      Returns the checks in the specified status
      Overrides:
        `rxHealthState` in class `ConsulClient`
      Parameters:
        `healthState` - the health state
      Returns:
        reference to this, for fluency

    - #### healthStateWithOptions

          public ConsulService healthStateWithOptions(HealthState healthState,
                                                      CheckQueryOptions checkQueryOptions,
                                                      Handler<AsyncResult<CheckList>> handler)

      Description copied from class: `ConsulClient`
      Returns the checks in the specified status
      Overrides:
        `healthStateWithOptions` in class `ConsulClient`
      Parameters:
        `healthState` - the health state
        `checkQueryOptions` - options used to request checks
        `handler` - will be provided with list of checks
      Returns:
        reference to this, for fluency

    - #### rxHealthStateWithOptions

          public Single<CheckList> rxHealthStateWithOptions(HealthState healthState,
                                                            CheckQueryOptions checkQueryOptions)

      Description copied from class: `ConsulClient`
      Returns the checks in the specified status
      Overrides:
        `rxHealthStateWithOptions` in class `ConsulClient`
      Parameters:
        `healthState` - the health state
        `checkQueryOptions` - options used to request checks
      Returns:
        reference to this, for fluency

    - #### healthServiceNodes

          public ConsulService healthServiceNodes(String service,
                                                  boolean passing,
                                                  Handler<AsyncResult<ServiceEntryList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes providing the service. This endpoint is very similar to the `ConsulClient.catalogServiceNodes(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)` endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
      Overrides:
        `healthServiceNodes` in class `ConsulClient`
      Parameters:
        `service` - the service name
        `passing` - if true, filter results to only nodes with all checks in the passing state
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxHealthServiceNodes

          public Single<ServiceEntryList> rxHealthServiceNodes(String service,
                                                               boolean passing)

      Description copied from class: `ConsulClient`
      Returns the nodes providing the service. This endpoint is very similar to the `ConsulClient.catalogServiceNodes(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)` endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
      Overrides:
        `rxHealthServiceNodes` in class `ConsulClient`
      Parameters:
        `service` - the service name
        `passing` - if true, filter results to only nodes with all checks in the passing state
      Returns:
        reference to this, for fluency

    - #### healthServiceNodesWithOptions

          public ConsulService healthServiceNodesWithOptions(String service,
                                                             boolean passing,
                                                             ServiceQueryOptions options,
                                                             Handler<AsyncResult<ServiceEntryList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes providing the service. This endpoint is very similar to the `ConsulClient.catalogServiceNodesWithOptions(java.lang.String, io.vertx.ext.consul.ServiceQueryOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)` endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
      Overrides:
        `healthServiceNodesWithOptions` in class `ConsulClient`
      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
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxHealthServiceNodesWithOptions

          public Single<ServiceEntryList> rxHealthServiceNodesWithOptions(String service,
                                                                          boolean passing,
                                                                          ServiceQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the nodes providing the service. This endpoint is very similar to the `ConsulClient.catalogServiceNodesWithOptions(java.lang.String, io.vertx.ext.consul.ServiceQueryOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)` endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
      Overrides:
        `rxHealthServiceNodesWithOptions` in class `ConsulClient`
      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:
        reference to this, for fluency

    - #### catalogServiceNodes

          public ConsulService catalogServiceNodes(String service,
                                                   Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes providing a service
      Overrides:
        `catalogServiceNodes` in class `ConsulClient`
      Parameters:
        `service` - name of service
        `resultHandler` - will be provided with list of nodes providing given service
      Returns:
        reference to this, for fluency

    - #### rxCatalogServiceNodes

          public Single<ServiceList> rxCatalogServiceNodes(String service)

      Description copied from class: `ConsulClient`
      Returns the nodes providing a service
      Overrides:
        `rxCatalogServiceNodes` in class `ConsulClient`
      Parameters:
        `service` - name of service
      Returns:
        reference to this, for fluency

    - #### catalogServiceNodesWithOptions

          public ConsulService catalogServiceNodesWithOptions(String service,
                                                              ServiceQueryOptions options,
                                                              Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes providing a service
      Overrides:
        `catalogServiceNodesWithOptions` in class `ConsulClient`
      Parameters:
        `service` - name of service
        `options` - options used to request services
        `resultHandler` - will be provided with list of nodes providing given service
      Returns:
        reference to this, for fluency

    - #### rxCatalogServiceNodesWithOptions

          public Single<ServiceList> rxCatalogServiceNodesWithOptions(String service,
                                                                      ServiceQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the nodes providing a service
      Overrides:
        `rxCatalogServiceNodesWithOptions` in class `ConsulClient`
      Parameters:
        `service` - name of service
        `options` - options used to request services
      Returns:
        reference to this, for fluency

    - #### catalogDatacenters

          public ConsulService catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)

      Description copied from class: `ConsulClient`
      Return all the datacenters that are known by the Consul server
      Overrides:
        `catalogDatacenters` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of datacenters
      Returns:
        reference to this, for fluency

    - #### rxCatalogDatacenters

          public Single<List<String>> rxCatalogDatacenters()

      Description copied from class: `ConsulClient`
      Return all the datacenters that are known by the Consul server
      Overrides:
        `rxCatalogDatacenters` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### catalogNodes

          public ConsulService catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes registered in a datacenter
      Overrides:
        `catalogNodes` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of nodes
      Returns:
        reference to this, for fluency

    - #### rxCatalogNodes

          public Single<NodeList> rxCatalogNodes()

      Description copied from class: `ConsulClient`
      Returns the nodes registered in a datacenter
      Overrides:
        `rxCatalogNodes` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### catalogNodesWithOptions

          public ConsulService catalogNodesWithOptions(NodeQueryOptions options,
                                                       Handler<AsyncResult<NodeList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the nodes registered in a datacenter
      Overrides:
        `catalogNodesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - options used to request nodes
        `resultHandler` - will be provided with list of nodes
      Returns:
        reference to this, for fluency

    - #### rxCatalogNodesWithOptions

          public Single<NodeList> rxCatalogNodesWithOptions(NodeQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the nodes registered in a datacenter
      Overrides:
        `rxCatalogNodesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - options used to request nodes
      Returns:
        reference to this, for fluency

    - #### catalogServices

          public ConsulService catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the services registered in a datacenter
      Overrides:
        `catalogServices` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxCatalogServices

          public Single<ServiceList> rxCatalogServices()

      Description copied from class: `ConsulClient`
      Returns the services registered in a datacenter
      Overrides:
        `rxCatalogServices` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### catalogServicesWithOptions

          public ConsulService catalogServicesWithOptions(BlockingQueryOptions options,
                                                          Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
      Overrides:
        `catalogServicesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxCatalogServicesWithOptions

          public Single<ServiceList> rxCatalogServicesWithOptions(BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
      Overrides:
        `rxCatalogServicesWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### localServices

          public ConsulService localServices(Handler<AsyncResult<List<Service>>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns list of services registered with the local agent.
      Overrides:
        `localServices` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxLocalServices

          public Single<List<Service>> rxLocalServices()

      Description copied from class: `ConsulClient`
      Returns list of services registered with the local agent.
      Overrides:
        `rxLocalServices` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### catalogNodeServices

          public ConsulService catalogNodeServices(String node,
                                                   Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the node's registered services
      Overrides:
        `catalogNodeServices` in class `ConsulClient`
      Parameters:
        `node` - node name
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxCatalogNodeServices

          public Single<ServiceList> rxCatalogNodeServices(String node)

      Description copied from class: `ConsulClient`
      Returns the node's registered services
      Overrides:
        `rxCatalogNodeServices` in class `ConsulClient`
      Parameters:
        `node` - node name
      Returns:
        reference to this, for fluency

    - #### catalogNodeServicesWithOptions

          public ConsulService catalogNodeServicesWithOptions(String node,
                                                              BlockingQueryOptions options,
                                                              Handler<AsyncResult<ServiceList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
      Overrides:
        `catalogNodeServicesWithOptions` in class `ConsulClient`
      Parameters:
        `node` - node name
        `options` - the blocking options
        `resultHandler` - will be provided with list of services
      Returns:
        reference to this, for fluency

    - #### rxCatalogNodeServicesWithOptions

          public Single<ServiceList> rxCatalogNodeServicesWithOptions(String node,
                                                                      BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
      Overrides:
        `rxCatalogNodeServicesWithOptions` in class `ConsulClient`
      Parameters:
        `node` - node name
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### localChecks

          public ConsulService localChecks(Handler<AsyncResult<List<Check>>> resultHandler)

      Description copied from class: `ConsulClient`
      Return all the checks that are registered with the local agent.
      Overrides:
        `localChecks` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of checks
      Returns:
        reference to this, for fluency

    - #### rxLocalChecks

          public Single<List<Check>> rxLocalChecks()

      Description copied from class: `ConsulClient`
      Return all the checks that are registered with the local agent.
      Overrides:
        `rxLocalChecks` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### registerCheck

          public ConsulService registerCheck(CheckOptions checkOptions,
                                             Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `registerCheck` in class `ConsulClient`
      Parameters:
        `checkOptions` - options used to register new check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxRegisterCheck

          public Completable rxRegisterCheck(CheckOptions checkOptions)

      Description copied from class: `ConsulClient`
      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.
      Overrides:
        `rxRegisterCheck` in class `ConsulClient`
      Parameters:
        `checkOptions` - options used to register new check
      Returns:
        reference to this, for fluency

    - #### deregisterCheck

          public ConsulService deregisterCheck(String checkId,
                                               Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
      Overrides:
        `deregisterCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxDeregisterCheck

          public Completable rxDeregisterCheck(String checkId)

      Description copied from class: `ConsulClient`
      Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
      Overrides:
        `rxDeregisterCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
      Returns:
        reference to this, for fluency

    - #### passCheck

          public ConsulService passCheck(String checkId,
                                         Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `passCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxPassCheck

          public Completable rxPassCheck(String checkId)

      Description copied from class: `ConsulClient`
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxPassCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
      Returns:
        reference to this, for fluency

    - #### passCheckWithNote

          public ConsulService passCheckWithNote(String checkId,
                                                 String note,
                                                 Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `passCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxPassCheckWithNote

          public Completable rxPassCheckWithNote(String checkId,
                                                 String note)

      Description copied from class: `ConsulClient`
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxPassCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
      Returns:
        reference to this, for fluency

    - #### warnCheck

          public ConsulService warnCheck(String checkId,
                                         Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `warnCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxWarnCheck

          public Completable rxWarnCheck(String checkId)

      Description copied from class: `ConsulClient`
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxWarnCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
      Returns:
        reference to this, for fluency

    - #### warnCheckWithNote

          public ConsulService warnCheckWithNote(String checkId,
                                                 String note,
                                                 Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `warnCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxWarnCheckWithNote

          public Completable rxWarnCheckWithNote(String checkId,
                                                 String note)

      Description copied from class: `ConsulClient`
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxWarnCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
      Returns:
        reference to this, for fluency

    - #### failCheck

          public ConsulService failCheck(String checkId,
                                         Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `failCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxFailCheck

          public Completable rxFailCheck(String checkId)

      Description copied from class: `ConsulClient`
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxFailCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
      Returns:
        reference to this, for fluency

    - #### failCheckWithNote

          public ConsulService failCheckWithNote(String checkId,
                                                 String note,
                                                 Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `failCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxFailCheckWithNote

          public Completable rxFailCheckWithNote(String checkId,
                                                 String note)

      Description copied from class: `ConsulClient`
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxFailCheckWithNote` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `note` - specifies a human-readable message. This will be passed through to the check's `Output` field.
      Returns:
        reference to this, for fluency

    - #### updateCheck

          public ConsulService updateCheck(String checkId,
                                           CheckStatus status,
                                           Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `updateCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `status` - new status of check
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxUpdateCheck

          public Completable rxUpdateCheck(String checkId,
                                           CheckStatus status)

      Description copied from class: `ConsulClient`
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxUpdateCheck` in class `ConsulClient`
      Parameters:
        `checkId` - the ID of check
        `status` - new status of check
      Returns:
        reference to this, for fluency

    - #### updateCheckWithNote

          public ConsulService updateCheckWithNote(String checkId,
                                                   CheckStatus status,
                                                   String note,
                                                   Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `updateCheckWithNote` in class `ConsulClient`
      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.
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxUpdateCheckWithNote

          public Completable rxUpdateCheckWithNote(String checkId,
                                                   CheckStatus status,
                                                   String note)

      Description copied from class: `ConsulClient`
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
      Overrides:
        `rxUpdateCheckWithNote` in class `ConsulClient`
      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:
        reference to this, for fluency

    - #### leaderStatus

          public ConsulService leaderStatus(Handler<AsyncResult<String>> resultHandler)

      Description copied from class: `ConsulClient`
      Get the Raft leader for the datacenter in which the agent is running. It returns an address in format "`10.1.10.12:8300`"
      Overrides:
        `leaderStatus` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with address of cluster leader
      Returns:
        reference to this, for fluency

    - #### rxLeaderStatus

          public Single<String> rxLeaderStatus()

      Description copied from class: `ConsulClient`
      Get the Raft leader for the datacenter in which the agent is running. It returns an address in format "`10.1.10.12:8300`"
      Overrides:
        `rxLeaderStatus` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### peersStatus

          public ConsulService peersStatus(Handler<AsyncResult<List<String>>> resultHandler)

      Description copied from class: `ConsulClient`
      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`"
      Overrides:
        `peersStatus` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of peers
      Returns:
        reference to this, for fluency

    - #### rxPeersStatus

          public Single<List<String>> rxPeersStatus()

      Description copied from class: `ConsulClient`
      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`"
      Overrides:
        `rxPeersStatus` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### createSession

          public ConsulService createSession(Handler<AsyncResult<String>> idHandler)

      Description copied from class: `ConsulClient`
      Initialize a new session
      Overrides:
        `createSession` in class `ConsulClient`
      Parameters:
        `idHandler` - will be provided with ID of new session
      Returns:
        reference to this, for fluency

    - #### rxCreateSession

          public Single<String> rxCreateSession()

      Description copied from class: `ConsulClient`
      Initialize a new session
      Overrides:
        `rxCreateSession` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### createSessionWithOptions

          public ConsulService createSessionWithOptions(SessionOptions options,
                                                        Handler<AsyncResult<String>> idHandler)

      Description copied from class: `ConsulClient`
      Initialize a new session
      Overrides:
        `createSessionWithOptions` in class `ConsulClient`
      Parameters:
        `options` - options used to create session
        `idHandler` - will be provided with ID of new session
      Returns:
        reference to this, for fluency

    - #### rxCreateSessionWithOptions

          public Single<String> rxCreateSessionWithOptions(SessionOptions options)

      Description copied from class: `ConsulClient`
      Initialize a new session
      Overrides:
        `rxCreateSessionWithOptions` in class `ConsulClient`
      Parameters:
        `options` - options used to create session
      Returns:
        reference to this, for fluency

    - #### infoSession

          public ConsulService infoSession(String id,
                                           Handler<AsyncResult<Session>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the requested session information
      Overrides:
        `infoSession` in class `ConsulClient`
      Parameters:
        `id` - the ID of requested session
        `resultHandler` - will be provided with info of requested session
      Returns:
        reference to this, for fluency

    - #### rxInfoSession

          public Single<Session> rxInfoSession(String id)

      Description copied from class: `ConsulClient`
      Returns the requested session information
      Overrides:
        `rxInfoSession` in class `ConsulClient`
      Parameters:
        `id` - the ID of requested session
      Returns:
        reference to this, for fluency

    - #### infoSessionWithOptions

          public ConsulService infoSessionWithOptions(String id,
                                                      BlockingQueryOptions options,
                                                      Handler<AsyncResult<Session>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
      Overrides:
        `infoSessionWithOptions` in class `ConsulClient`
      Parameters:
        `id` - the ID of requested session
        `options` - the blocking options
        `resultHandler` - will be provided with info of requested session
      Returns:
        reference to this, for fluency

    - #### rxInfoSessionWithOptions

          public Single<Session> rxInfoSessionWithOptions(String id,
                                                          BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
      Overrides:
        `rxInfoSessionWithOptions` in class `ConsulClient`
      Parameters:
        `id` - the ID of requested session
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### renewSession

          public ConsulService renewSession(String id,
                                            Handler<AsyncResult<Session>> resultHandler)

      Description copied from class: `ConsulClient`
      Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
      Overrides:
        `renewSession` in class `ConsulClient`
      Parameters:
        `id` - the ID of session that should be renewed
        `resultHandler` - will be provided with info of renewed session
      Returns:
        reference to this, for fluency

    - #### rxRenewSession

          public Single<Session> rxRenewSession(String id)

      Description copied from class: `ConsulClient`
      Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
      Overrides:
        `rxRenewSession` in class `ConsulClient`
      Parameters:
        `id` - the ID of session that should be renewed
      Returns:
        reference to this, for fluency

    - #### listSessions

          public ConsulService listSessions(Handler<AsyncResult<SessionList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the active sessions
      Overrides:
        `listSessions` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of sessions
      Returns:
        reference to this, for fluency

    - #### rxListSessions

          public Single<SessionList> rxListSessions()

      Description copied from class: `ConsulClient`
      Returns the active sessions
      Overrides:
        `rxListSessions` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### listSessionsWithOptions

          public ConsulService listSessionsWithOptions(BlockingQueryOptions options,
                                                       Handler<AsyncResult<SessionList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
      Overrides:
        `listSessionsWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
        `resultHandler` - will be provided with list of sessions
      Returns:
        reference to this, for fluency

    - #### rxListSessionsWithOptions

          public Single<SessionList> rxListSessionsWithOptions(BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
      Overrides:
        `rxListSessionsWithOptions` in class `ConsulClient`
      Parameters:
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### listNodeSessions

          public ConsulService listNodeSessions(String nodeId,
                                                Handler<AsyncResult<SessionList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the active sessions for a given node
      Overrides:
        `listNodeSessions` in class `ConsulClient`
      Parameters:
        `nodeId` - the ID of node
        `resultHandler` - will be provided with list of sessions
      Returns:
        reference to this, for fluency

    - #### rxListNodeSessions

          public Single<SessionList> rxListNodeSessions(String nodeId)

      Description copied from class: `ConsulClient`
      Returns the active sessions for a given node
      Overrides:
        `rxListNodeSessions` in class `ConsulClient`
      Parameters:
        `nodeId` - the ID of node
      Returns:
        reference to this, for fluency

    - #### listNodeSessionsWithOptions

          public ConsulService listNodeSessionsWithOptions(String nodeId,
                                                           BlockingQueryOptions options,
                                                           Handler<AsyncResult<SessionList>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
      Overrides:
        `listNodeSessionsWithOptions` in class `ConsulClient`
      Parameters:
        `nodeId` - the ID of node
        `options` - the blocking options
        `resultHandler` - will be provided with list of sessions
      Returns:
        reference to this, for fluency

    - #### rxListNodeSessionsWithOptions

          public Single<SessionList> rxListNodeSessionsWithOptions(String nodeId,
                                                                   BlockingQueryOptions options)

      Description copied from class: `ConsulClient`
      Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
      Overrides:
        `rxListNodeSessionsWithOptions` in class `ConsulClient`
      Parameters:
        `nodeId` - the ID of node
        `options` - the blocking options
      Returns:
        reference to this, for fluency

    - #### destroySession

          public ConsulService destroySession(String id,
                                              Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Destroys the given session
      Overrides:
        `destroySession` in class `ConsulClient`
      Parameters:
        `id` - the ID of session
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxDestroySession

          public Completable rxDestroySession(String id)

      Description copied from class: `ConsulClient`
      Destroys the given session
      Overrides:
        `rxDestroySession` in class `ConsulClient`
      Parameters:
        `id` - the ID of session
      Returns:
        reference to this, for fluency

    - #### createPreparedQuery

          public ConsulService createPreparedQuery(PreparedQueryDefinition definition,
                                                   Handler<AsyncResult<String>> resultHandler)

      Overrides:
        `createPreparedQuery` in class `ConsulClient`
      Parameters:
        `definition` - definition of the prepare query
        `resultHandler` - will be provided with id of created prepare query
      Returns:
        reference to this, for fluency

    - #### rxCreatePreparedQuery

          public Single<String> rxCreatePreparedQuery(PreparedQueryDefinition definition)

      Overrides:
        `rxCreatePreparedQuery` in class `ConsulClient`
      Parameters:
        `definition` - definition of the prepare query
      Returns:
        reference to this, for fluency

    - #### getPreparedQuery

          public ConsulService getPreparedQuery(String id,
                                                Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns an existing prepared query
      Overrides:
        `getPreparedQuery` in class `ConsulClient`
      Parameters:
        `id` - the id of the query to read
        `resultHandler` - will be provided with definition of the prepare query
      Returns:
        reference to this, for fluency

    - #### rxGetPreparedQuery

          public Single<PreparedQueryDefinition> rxGetPreparedQuery(String id)

      Description copied from class: `ConsulClient`
      Returns an existing prepared query
      Overrides:
        `rxGetPreparedQuery` in class `ConsulClient`
      Parameters:
        `id` - the id of the query to read
      Returns:
        reference to this, for fluency

    - #### getAllPreparedQueries

          public ConsulService getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)

      Description copied from class: `ConsulClient`
      Returns a list of all prepared queries.
      Overrides:
        `getAllPreparedQueries` in class `ConsulClient`
      Parameters:
        `resultHandler` - will be provided with list of definitions of the all prepare queries
      Returns:
        reference to this, for fluency

    - #### rxGetAllPreparedQueries

          public Single<List<PreparedQueryDefinition>> rxGetAllPreparedQueries()

      Description copied from class: `ConsulClient`
      Returns a list of all prepared queries.
      Overrides:
        `rxGetAllPreparedQueries` in class `ConsulClient`
      Returns:
        reference to this, for fluency

    - #### updatePreparedQuery

          public ConsulService updatePreparedQuery(PreparedQueryDefinition definition,
                                                   Handler<AsyncResult<Void>> resultHandler)

      Overrides:
        `updatePreparedQuery` in class `ConsulClient`
      Parameters:
        `definition` - definition of the prepare query
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxUpdatePreparedQuery

          public Completable rxUpdatePreparedQuery(PreparedQueryDefinition definition)

      Overrides:
        `rxUpdatePreparedQuery` in class `ConsulClient`
      Parameters:
        `definition` - definition of the prepare query
      Returns:
        reference to this, for fluency

    - #### deletePreparedQuery

          public ConsulService deletePreparedQuery(String id,
                                                   Handler<AsyncResult<Void>> resultHandler)

      Description copied from class: `ConsulClient`
      Deletes an existing prepared query
      Overrides:
        `deletePreparedQuery` in class `ConsulClient`
      Parameters:
        `id` - the id of the query to delete
        `resultHandler` - will be called when complete
      Returns:
        reference to this, for fluency

    - #### rxDeletePreparedQuery

          public Completable rxDeletePreparedQuery(String id)

      Description copied from class: `ConsulClient`
      Deletes an existing prepared query
      Overrides:
        `rxDeletePreparedQuery` in class `ConsulClient`
      Parameters:
        `id` - the id of the query to delete
      Returns:
        reference to this, for fluency

    - #### executePreparedQuery

          public ConsulService executePreparedQuery(String query,
                                                    Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)

      Description copied from class: `ConsulClient`
      Executes an existing prepared query.
      Overrides:
        `executePreparedQuery` in class `ConsulClient`
      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.
        `resultHandler` - will be provided with response
      Returns:
        reference to this, for fluency

    - #### rxExecutePreparedQuery

          public Single<PreparedQueryExecuteResponse> rxExecutePreparedQuery(String query)

      Description copied from class: `ConsulClient`
      Executes an existing prepared query.
      Overrides:
        `rxExecutePreparedQuery` in class `ConsulClient`
      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:
        reference to this, for fluency

    - #### executePreparedQueryWithOptions

          public ConsulService executePreparedQueryWithOptions(String query,
                                                               PreparedQueryExecuteOptions options,
                                                               Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)

      Description copied from class: `ConsulClient`
      Executes an existing prepared query.
      Overrides:
        `executePreparedQueryWithOptions` in class `ConsulClient`
      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
        `resultHandler` - will be provided with response
      Returns:
        reference to this, for fluency

    - #### rxExecutePreparedQueryWithOptions

          public Single<PreparedQueryExecuteResponse> rxExecutePreparedQueryWithOptions(String query,
                                                                                        PreparedQueryExecuteOptions options)

      Description copied from class: `ConsulClient`
      Executes an existing prepared query.
      Overrides:
        `rxExecutePreparedQueryWithOptions` in class `ConsulClient`
      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:
        reference to this, for fluency

    - #### close

          public void close()

      Description copied from class: `ConsulClient`
      Close the client and release its resources
      Overrides:
        `close` in class `ConsulClient`

    - #### newInstance

          public static ConsulService newInstance(io.vertx.ext.consul.ConsulService arg)

Copyright © 2018 Eclipse. All rights reserved.