## Uses of Class
io.vertx.core.json.JsonArray

- Packages that use JsonArray
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.core.buffer |
  io.vertx.core.json |
  io.vertx.core.parsetools |
  io.vertx.ext.auth.jdbc |
  io.vertx.ext.auth.oauth2 |
  io.vertx.ext.mongo |
  io.vertx.ext.sql |
  io.vertx.ext.web |
  io.vertx.ext.web.api |
  io.vertx.ext.web.api.generator |
  io.vertx.ext.web.client |
  io.vertx.ext.web.codec |
  io.vertx.kafka.client.serialization |
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.core.buffer |
  io.vertx.reactivex.core.parsetools |
  io.vertx.reactivex.ext.asyncsql |
  io.vertx.reactivex.ext.auth.jdbc |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.jdbc |
  io.vertx.reactivex.ext.mongo |
  io.vertx.reactivex.ext.sql |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.api |
  io.vertx.reactivex.ext.web.client |
  io.vertx.reactivex.ext.web.codec |
  io.vertx.reactivex.redis |
  io.vertx.reactivex.redis.sentinel |
  io.vertx.redis |
  io.vertx.redis.op |
  io.vertx.redis.sentinel |
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.core.buffer |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.ext.asyncsql |
  io.vertx.rxjava.ext.auth.jdbc |
  io.vertx.rxjava.ext.auth.oauth2 |
  io.vertx.rxjava.ext.jdbc |
  io.vertx.rxjava.ext.mongo |
  io.vertx.rxjava.ext.sql |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.api |
  io.vertx.rxjava.ext.web.client |
  io.vertx.rxjava.ext.web.codec |
  io.vertx.rxjava.redis |
  io.vertx.rxjava.redis.sentinel |
  io.vertx.serviceproxy |

- - ### Uses of JsonArray in io.vertx.amqp

    Methods in io.vertx.amqp that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | AmqpMessage.`bodyAsJsonArray()`

    Methods in io.vertx.amqp with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `AmqpMessageBuilder` | AmqpMessageBuilder.`withJsonArrayAsBody(JsonArray json)`

  - ### Uses of JsonArray in io.vertx.core.buffer

    Methods in io.vertx.core.buffer that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | Buffer.`toJsonArray()` Returns a Json array representation of the Buffer.

  - ### Uses of JsonArray in io.vertx.core.json

    Methods in io.vertx.core.json that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonArray.`add(Boolean value)` Add a Boolean to the JSON array.
    `JsonArray` | JsonArray.`add(byte[] value)` Add a binary value to the JSON array.
    `JsonArray` | JsonArray.`add(CharSequence value)` Add a CharSequence to the JSON array.
    `JsonArray` | JsonArray.`add(Double value)` Add a Double to the JSON array.
    `JsonArray` | JsonArray.`add(Enum value)` Add an enum to the JSON array.
    `JsonArray` | JsonArray.`add(Float value)` Add a Float to the JSON array.
    `JsonArray` | JsonArray.`add(java.time.Instant value)` Add a Instant value to the JSON array.
    `JsonArray` | JsonArray.`add(Integer value)` Add an Integer to the JSON array.
    `JsonArray` | JsonArray.`add(JsonArray value)` Add another JSON array to the JSON array.
    `JsonArray` | JsonArray.`add(JsonObject value)` Add a JSON object to the JSON array.
    `JsonArray` | JsonArray.`add(Long value)` Add a Long to the JSON array.
    `JsonArray` | JsonArray.`add(Object value)` Add an Object to the JSON array.
    `JsonArray` | JsonArray.`add(String value)` Add a String to the JSON array.
    `JsonArray` | JsonArray.`addAll(JsonArray array)` Appends all of the elements in the specified array to the end of this JSON array.
    `JsonArray` | JsonArray.`addNull()` Add a null value to the JSON array.
    `JsonArray` | JsonArray.`clear()` Remove all entries from the JSON array
    `JsonArray` | JsonArray.`copy()` Make a copy of the JSON array
    `JsonArray` | JsonArray.`getJsonArray(int pos)` Get the JsonArray at position `pos` in the array.
    `JsonArray` | JsonObject.`getJsonArray(String key)` Get the JsonArray value with the specified key
    `JsonArray` | JsonObject.`getJsonArray(String key, JsonArray def)` Like `JsonObject.getJsonArray(String)` but specifying a default value to return if there is no entry.
    `JsonArray` | JsonArray.`set(int pos, Boolean value)` Set a Boolean to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, byte[] value)` Set a binary value to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, CharSequence value)` Set a CharSequence to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Double value)` Set a Double to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Enum value)` Set an enum to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Float value)` Set a Float to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, java.time.Instant value)` Set a Instant value to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Integer value)` Set an Integer to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, JsonArray value)` Set another JSON array to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, JsonObject value)` Set a JSON object to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Long value)` Set a Long to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, Object value)` Set an Object to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`set(int pos, String value)` Set a String to the JSON array at position `pos`.
    `JsonArray` | JsonArray.`setNull(int pos)` Set a null value to the JSON array at position `pos`.

    Methods in io.vertx.core.json with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonArray.`add(JsonArray value)` Add another JSON array to the JSON array.
    `JsonArray` | JsonArray.`addAll(JsonArray array)` Appends all of the elements in the specified array to the end of this JSON array.
    `JsonArray` | JsonObject.`getJsonArray(String key, JsonArray def)` Like `JsonObject.getJsonArray(String)` but specifying a default value to return if there is no entry.
    `JsonObject` | JsonObject.`put(String key, JsonArray value)` Put a JSON array into the JSON object with the specified key.
    `JsonArray` | JsonArray.`set(int pos, JsonArray value)` Set another JSON array to the JSON array at position `pos`.

  - ### Uses of JsonArray in io.vertx.core.parsetools

    Methods in io.vertx.core.parsetools that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonEvent.`arrayValue()`

  - ### Uses of JsonArray in io.vertx.ext.auth.jdbc

    Methods in io.vertx.ext.auth.jdbc with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `String` | JDBCHashStrategy.`getHashedStoredPwd(JsonArray row)` Retrieve the hashed password from the result of the authentication query
    `String` | JDBCHashStrategy.`getSalt(JsonArray row)` Retrieve the salt from the result of the authentication query
    `void` | JDBCHashStrategy.`setNonces(JsonArray nonces)` Sets a ordered list of nonces where each position corresponds to a version.
    `JDBCAuth` | JDBCAuth.`setNonces(JsonArray nonces)` Provide a application configuration level on hash nonce's as a ordered list of nonces where each position corresponds to a version.

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

    Methods in io.vertx.ext.auth.oauth2 that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | OAuth2Response.`jsonArray()` The HTTP response body as a JsonArray

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

    Methods in io.vertx.ext.mongo with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonObject>` | MongoClient.`aggregate(String collection, JsonArray pipeline)` Run aggregate MongoDB command with default `AggregateOptions`.
    `default ReadStream<JsonObject>` | MongoService.`aggregate(String collection, JsonArray pipeline)`
    `ReadStream<JsonObject>` | MongoClient.`aggregateWithOptions(String collection, JsonArray pipeline, AggregateOptions options)` Run aggregate MongoDB command.
    `default ReadStream<JsonObject>` | MongoService.`aggregateWithOptions(String collection, JsonArray pipeline, AggregateOptions options)`

    Method parameters in io.vertx.ext.mongo with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`

  - ### Uses of JsonArray in io.vertx.ext.sql

    Methods in io.vertx.ext.sql that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | SQLOptions.`getAutoGeneratedKeysIndexes()`
    `JsonArray` | UpdateResult.`getKeys()` Get any generated keys
    `JsonArray` | ResultSet.`getOutput()` Get the registered outputs

    Methods in io.vertx.ext.sql that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `List<JsonArray>` | ResultSet.`getResults()` Get the results

    Methods in io.vertx.ext.sql with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `default SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `default SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLOptions` | SQLOptions.`setAutoGeneratedKeysIndexes(JsonArray autoGeneratedKeysIndexes)`
    `UpdateResult` | UpdateResult.`setKeys(JsonArray keys)`
    `ResultSet` | ResultSet.`setOutput(JsonArray output)`
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `default SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

    Method parameters in io.vertx.ext.sql with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `default SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `default SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `ResultSet` | ResultSet.`setResults(List<JsonArray> results)`

    Constructors in io.vertx.ext.sql with parameters of type JsonArray
    Constructor and Description
    `UpdateResult(int updated, JsonArray keys)` Constructor

    Constructor parameters in io.vertx.ext.sql with type arguments of type JsonArray
    Constructor and Description
    `ResultSet(List<String> columnNames, List<JsonArray> results, ResultSet next)` Create a result-set

  - ### Uses of JsonArray in io.vertx.ext.web

    Methods in io.vertx.ext.web that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RoutingContext.`getBodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.ext.web.api

    Methods in io.vertx.ext.web.api that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RequestParameter.`getJsonArray()` Returns null if value is not a JsonArray, otherwise it returns value

    Methods in io.vertx.ext.web.api with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static OperationResponse` | OperationResponse.`completedWithJson(JsonArray jsonArray)`

  - ### Uses of JsonArray in io.vertx.ext.web.api.generator

    Methods in io.vertx.ext.web.api.generator that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static JsonArray` | ApiHandlerUtils.`searchJsonArrayInJson(JsonObject obj, String key)`

    Methods in io.vertx.ext.web.api.generator that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static Optional<JsonArray>` | ApiHandlerUtils.`searchOptionalJsonArrayInJson(JsonObject obj, String key)`

  - ### Uses of JsonArray in io.vertx.ext.web.client

    Methods in io.vertx.ext.web.client that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | HttpResponse.`bodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.ext.web.codec

    Methods in io.vertx.ext.web.codec that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static BodyCodec<JsonArray>` | BodyCodec.`jsonArray()`

  - ### Uses of JsonArray in io.vertx.kafka.client.serialization

    Methods in io.vertx.kafka.client.serialization that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonArrayDeserializer.`deserialize(String topic, byte[] data)`

    Methods in io.vertx.kafka.client.serialization that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static org.apache.kafka.common.serialization.Serde<JsonArray>` | VertxSerdes.`JsonArray()`

    Methods in io.vertx.kafka.client.serialization with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `byte[]` | JsonArraySerializer.`serialize(String topic, JsonArray data)`

  - ### Uses of JsonArray in io.vertx.reactivex.amqp

    Methods in io.vertx.reactivex.amqp that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | AmqpMessage.`bodyAsJsonArray()`

    Methods in io.vertx.reactivex.amqp with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `AmqpMessageBuilder` | AmqpMessageBuilder.`withJsonArrayAsBody(JsonArray json)`

  - ### Uses of JsonArray in io.vertx.reactivex.core.buffer

    Methods in io.vertx.reactivex.core.buffer that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | Buffer.`toJsonArray()` Returns a Json array representation of the Buffer.

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

    Methods in io.vertx.reactivex.core.parsetools that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonEvent.`arrayValue()`

  - ### Uses of JsonArray in io.vertx.reactivex.ext.asyncsql

    Methods in io.vertx.reactivex.ext.asyncsql that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<JsonArray>` | PostgreSQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | AsyncSQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | MySQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | PostgreSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | AsyncSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | MySQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Methods in io.vertx.reactivex.ext.asyncsql with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | PostgreSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | AsyncSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | MySQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Method parameters in io.vertx.reactivex.ext.asyncsql with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of JsonArray in io.vertx.reactivex.ext.auth.jdbc

    Methods in io.vertx.reactivex.ext.auth.jdbc with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `String` | JDBCHashStrategy.`getHashedStoredPwd(JsonArray row)` Retrieve the hashed password from the result of the authentication query
    `String` | JDBCHashStrategy.`getSalt(JsonArray row)` Retrieve the salt from the result of the authentication query
    `void` | JDBCHashStrategy.`setNonces(JsonArray nonces)` Sets a ordered list of nonces where each position corresponds to a version.
    `JDBCAuth` | JDBCAuth.`setNonces(JsonArray nonces)` Provide a application configuration level on hash nonce's as a ordered list of nonces where each position corresponds to a version.

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

    Methods in io.vertx.reactivex.ext.auth.oauth2 that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | OAuth2Response.`jsonArray()` The HTTP response body as a JsonArray

  - ### Uses of JsonArray in io.vertx.reactivex.ext.jdbc

    Methods in io.vertx.reactivex.ext.jdbc that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<JsonArray>` | JDBCClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | JDBCClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Methods in io.vertx.reactivex.ext.jdbc with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | JDBCClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Method parameters in io.vertx.reactivex.ext.jdbc with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

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

    Methods in io.vertx.reactivex.ext.mongo that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Single<JsonArray>` | MongoClient.`rxDistinct(String collection, String fieldName, String resultClassname)` Gets the distinct values of the specified field name.
    `Single<JsonArray>` | MongoService.`rxDistinct(String collection, String fieldName, String resultClassname)`
    `Single<JsonArray>` | MongoClient.`rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Gets the distinct values of the specified field name filtered by specified query.
    `Single<JsonArray>` | MongoService.`rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)`
    `Single<JsonArray>` | MongoClient.`rxListIndexes(String collection)` Get all the indexes in this collection.
    `Single<JsonArray>` | MongoService.`rxListIndexes(String collection)`

    Methods in io.vertx.reactivex.ext.mongo with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonObject>` | MongoClient.`aggregate(String collection, JsonArray pipeline)` Run aggregate MongoDB command with default `AggregateOptions`.
    `ReadStream<JsonObject>` | MongoClient.`aggregateWithOptions(String collection, JsonArray pipeline, AggregateOptions options)` Run aggregate MongoDB command.

    Method parameters in io.vertx.reactivex.ext.mongo with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`

  - ### Uses of JsonArray in io.vertx.reactivex.ext.sql

    Methods in io.vertx.reactivex.ext.sql that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonArray>` | SQLRowStream.`fetch(long amount)` Fetch the specified `amount` of elements.
    `Pipe<JsonArray>` | SQLRowStream.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Maybe<JsonArray>` | SQLConnection.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | SQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Maybe<JsonArray>` | SQLConnection.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | SQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Flowable<JsonArray>` | SQLRowStream.`toFlowable()`
    `Observable<JsonArray>` | SQLRowStream.`toObservable()`

    Methods in io.vertx.reactivex.ext.sql with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Single<ResultSet>` | SQLConnection.`rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Single<ResultSet>` | SQLClient.`rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Maybe<JsonArray>` | SQLConnection.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Maybe<JsonArray>` | SQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<SQLRowStream>` | SQLConnection.`rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<SQLRowStream>` | SQLClient.`rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<ResultSet>` | SQLConnection.`rxQueryWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Single<ResultSet>` | SQLClient.`rxQueryWithParams(String sql, JsonArray arguments)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `Single<UpdateResult>` | SQLConnection.`rxUpdateWithParams(String sql, JsonArray params)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `Single<UpdateResult>` | SQLClient.`rxUpdateWithParams(String sql, JsonArray params)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

    Method parameters in io.vertx.reactivex.ext.sql with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst)` Like `ReadStream.pipeTo(io.vertx.reactivex.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<List<Integer>>` | SQLConnection.`rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `Single<List<Integer>>` | SQLConnection.`rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `Single<List<Integer>>` | SQLConnection.`rxBatchWithParams(String sqlStatement, List<JsonArray> args)` Batch a prepared statement with all entries from the args list.
    `Completable` | SQLRowStream.`rxPipeTo(WriteStream<JsonArray> dst)` Pipe this `ReadStream` to the `WriteStream`.

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

    Methods in io.vertx.reactivex.ext.web that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RoutingContext.`getBodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.reactivex.ext.web.api

    Methods in io.vertx.reactivex.ext.web.api that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RequestParameter.`getJsonArray()` Returns null if value is not a JsonArray, otherwise it returns value

  - ### Uses of JsonArray in io.vertx.reactivex.ext.web.client

    Methods in io.vertx.reactivex.ext.web.client that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | HttpResponse.`bodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.reactivex.ext.web.codec

    Methods in io.vertx.reactivex.ext.web.codec that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static BodyCodec<JsonArray>` | BodyCodec.`jsonArray()`

  - ### Uses of JsonArray in io.vertx.reactivex.redis

    Methods in io.vertx.reactivex.redis that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Single<JsonArray>` | RedisClient.`rxBitfield(String key, BitFieldOptions bitFieldOptions)` Perform arbitrary bitfield integer operations on strings.
    `Single<JsonArray>` | RedisClient.`rxBitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Perform arbitrary bitfield integer operations on strings.
    `Single<JsonArray>` | RedisClient.`rxBlpop(String key, int seconds)` Remove and get the first element in a list, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBlpopMany(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBrpop(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBrpopMany(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxClusterGetkeysinslot(long slot, long count)` Return local key names in the specified hash slot.
    `Single<JsonArray>` | RedisClient.`rxClusterInfo()` Provides info about Redis Cluster node state.
    `Single<JsonArray>` | RedisClient.`rxClusterNodes()` Get Cluster config for the node.
    `Single<JsonArray>` | RedisClient.`rxClusterSlaves(String nodeId)` List slave nodes of the specified master node.
    `Single<JsonArray>` | RedisClient.`rxClusterSlots()` Get array of Cluster slot to node mappings
    `Single<JsonArray>` | RedisClient.`rxCommand()` Get array of Redis command details
    `Single<JsonArray>` | RedisClient.`rxCommandGetkeys()` Extract keys given a full Redis command
    `Single<JsonArray>` | RedisClient.`rxCommandInfo(List<String> commands)` Get array of specific Redis command details
    `Single<JsonArray>` | RedisClient.`rxConfigGet(String parameter)` Get the value of a configuration parameter
    `Single<JsonArray>` | RedisClient.`rxEval(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisClient.`rxEvalScript(Script script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisClient.`rxEvalsha(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisTransaction.`rxExec()` Execute all commands issued after MULTI
    `Single<JsonArray>` | RedisClient.`rxGeohash(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<JsonArray>` | RedisClient.`rxGeohashMany(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<JsonArray>` | RedisClient.`rxGeopos(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<JsonArray>` | RedisClient.`rxGeoposMany(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<JsonArray>` | RedisClient.`rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<JsonArray>` | RedisClient.`rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<JsonArray>` | RedisClient.`rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<JsonArray>` | RedisClient.`rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<JsonArray>` | RedisClient.`rxHkeys(String key)` Get all the fields in a hash
    `Single<JsonArray>` | RedisClient.`rxHmget(String key, List<String> fields)` Get the values of all the given hash fields
    `Single<JsonArray>` | RedisClient.`rxHscan(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
    `Single<JsonArray>` | RedisClient.`rxHvals(String key)` Get all the values in a hash
    `Single<JsonArray>` | RedisClient.`rxKeys(String pattern)` Find all keys matching the given pattern
    `Single<JsonArray>` | RedisClient.`rxLrange(String key, long from, long to)` Get a range of elements from a list
    `Single<JsonArray>` | RedisClient.`rxMget(String key)` Get the value of the given key
    `Single<JsonArray>` | RedisClient.`rxMgetMany(List<String> keys)` Get the values of all the given keys
    `Single<JsonArray>` | RedisClient.`rxPsubscribe(String pattern)` Listen for messages published to channels matching the given pattern
    `Single<JsonArray>` | RedisClient.`rxPsubscribeMany(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `Single<JsonArray>` | RedisClient.`rxPubsubChannels(String pattern)` Lists the currently active channels - only those matching the pattern
    `Single<JsonArray>` | RedisClient.`rxPubsubNumsub(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `Single<JsonArray>` | RedisClient.`rxRole()` Return the role of the instance in the context of replication
    `Single<JsonArray>` | RedisClient.`rxScan(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `Single<JsonArray>` | RedisClient.`rxScriptExists(String script)` Check existence of script in the script cache.
    `Single<JsonArray>` | RedisClient.`rxScriptExistsMany(List<String> scripts)` Check existence of scripts in the script cache.
    `Single<JsonArray>` | RedisClient.`rxSdiff(String key, List<String> cmpkeys)` Subtract multiple sets
    `Single<JsonArray>` | RedisClient.`rxSinter(List<String> keys)` Intersect multiple sets
    `Single<JsonArray>` | RedisClient.`rxSlowlogGet(int limit)` Read the Redis slow queries log
    `Single<JsonArray>` | RedisTransaction.`rxSmembers(String key)` Get all the members in a set
    `Single<JsonArray>` | RedisClient.`rxSmembers(String key)` Get all the members in a set
    `Single<JsonArray>` | RedisClient.`rxSort(String key, SortOptions options)` Sort the elements in a list, set or sorted set
    `Single<JsonArray>` | RedisClient.`rxSpopMany(String key, int count)` Remove and return random members from a set
    `Single<JsonArray>` | RedisClient.`rxSrandmemberCount(String key, int count)` Get one or multiple random members from a set
    `Single<JsonArray>` | RedisClient.`rxSscan(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `Single<JsonArray>` | RedisClient.`rxSubscribe(String channel)` Listen for messages published to the given channels
    `Single<JsonArray>` | RedisClient.`rxSubscribeMany(List<String> channels)` Listen for messages published to the given channels
    `Single<JsonArray>` | RedisClient.`rxSunion(List<String> keys)` Add multiple sets
    `Single<JsonArray>` | RedisClient.`rxTime()` Return the current server time
    `Single<JsonArray>` | RedisClient.`rxZrange(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `Single<JsonArray>` | RedisClient.`rxZrangebylex(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
    `Single<JsonArray>` | RedisClient.`rxZrangebyscore(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `Single<JsonArray>` | RedisClient.`rxZrangeWithOptions(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
    `Single<JsonArray>` | RedisClient.`rxZrevrange(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZrevrangebylex(String key, String max, String min, LimitOptions options)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZscan(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores

    Method parameters in io.vertx.reactivex.redis with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores

  - ### Uses of JsonArray in io.vertx.reactivex.redis.sentinel

    Methods in io.vertx.reactivex.redis.sentinel that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Single<JsonArray>` | RedisSentinel.`rxGetMasterAddrByName(String name)` Return the ip and port number of the master with that name.
    `Single<JsonArray>` | RedisSentinel.`rxMaster(String name)` Show the state and info of the specified master
    `Single<JsonArray>` | RedisSentinel.`rxMasters()` Show a list of monitored masters and their state
    `Single<JsonArray>` | RedisSentinel.`rxSentinels(String name)` Show a list of sentinel instances for this master, and their state
    `Single<JsonArray>` | RedisSentinel.`rxSlaves(String name)` Show a list of slaves for this master, and their state

    Method parameters in io.vertx.reactivex.redis.sentinel with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of slaves for this master, and their state

  - ### Uses of JsonArray in io.vertx.redis

    Method parameters in io.vertx.redis with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores

  - ### Uses of JsonArray in io.vertx.redis.op

    Methods in io.vertx.redis.op that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RangeLimitOptions.`toJsonArray()`
    `JsonArray` | ShutdownOptions.`toJsonArray()`
    `JsonArray` | RangeOptions.`toJsonArray()`
    `JsonArray` | AggregateOptions.`toJsonArray()`
    `JsonArray` | ScanOptions.`toJsonArray()`
    `JsonArray` | KillFilter.`toJsonArray()`
    `JsonArray` | GeoMember.`toJsonArray()`
    `JsonArray` | MigrateOptions.`toJsonArray()`
    `JsonArray` | GeoRadiusOptions.`toJsonArray()`
    `JsonArray` | BitFieldOptions.`toJsonArray()`
    `JsonArray` | SetOptions.`toJsonArray()`
    `JsonArray` | SortOptions.`toJsonArray()`
    `JsonArray` | LimitOptions.`toJsonArray()`

  - ### Uses of JsonArray in io.vertx.redis.sentinel

    Method parameters in io.vertx.redis.sentinel with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of slaves for this master, and their state

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

    Methods in io.vertx.rxjava.amqp that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | AmqpMessage.`bodyAsJsonArray()`

    Methods in io.vertx.rxjava.amqp with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `AmqpMessageBuilder` | AmqpMessageBuilder.`withJsonArrayAsBody(JsonArray json)`

  - ### Uses of JsonArray in io.vertx.rxjava.core.buffer

    Methods in io.vertx.rxjava.core.buffer that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | Buffer.`toJsonArray()` Returns a Json array representation of the Buffer.

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

    Methods in io.vertx.rxjava.core.parsetools that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | JsonEvent.`arrayValue()`

  - ### Uses of JsonArray in io.vertx.rxjava.ext.asyncsql

    Methods in io.vertx.rxjava.ext.asyncsql that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Observable<JsonArray>` | PostgreSQLClient.`querySingleObservable(String sql)` Deprecated. use `PostgreSQLClient.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | AsyncSQLClient.`querySingleObservable(String sql)` Deprecated. use `AsyncSQLClient.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | MySQLClient.`querySingleObservable(String sql)` Deprecated. use `MySQLClient.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | PostgreSQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `PostgreSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | AsyncSQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `AsyncSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | MySQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `MySQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<JsonArray>` | PostgreSQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | AsyncSQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | MySQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | PostgreSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | AsyncSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | MySQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Methods in io.vertx.rxjava.ext.asyncsql with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Observable<JsonArray>` | PostgreSQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `PostgreSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | AsyncSQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `AsyncSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | MySQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `MySQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<JsonArray>` | PostgreSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | AsyncSQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | MySQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Method parameters in io.vertx.rxjava.ext.asyncsql with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of JsonArray in io.vertx.rxjava.ext.auth.jdbc

    Methods in io.vertx.rxjava.ext.auth.jdbc with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `String` | JDBCHashStrategy.`getHashedStoredPwd(JsonArray row)` Retrieve the hashed password from the result of the authentication query
    `String` | JDBCHashStrategy.`getSalt(JsonArray row)` Retrieve the salt from the result of the authentication query
    `void` | JDBCHashStrategy.`setNonces(JsonArray nonces)` Sets a ordered list of nonces where each position corresponds to a version.
    `JDBCAuth` | JDBCAuth.`setNonces(JsonArray nonces)` Provide a application configuration level on hash nonce's as a ordered list of nonces where each position corresponds to a version.

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

    Methods in io.vertx.rxjava.ext.auth.oauth2 that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | OAuth2Response.`jsonArray()` The HTTP response body as a JsonArray

  - ### Uses of JsonArray in io.vertx.rxjava.ext.jdbc

    Methods in io.vertx.rxjava.ext.jdbc that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Observable<JsonArray>` | JDBCClient.`querySingleObservable(String sql)` Deprecated. use `JDBCClient.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | JDBCClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `JDBCClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<JsonArray>` | JDBCClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | JDBCClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Methods in io.vertx.rxjava.ext.jdbc with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Observable<JsonArray>` | JDBCClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `JDBCClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<JsonArray>` | JDBCClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.

    Method parameters in io.vertx.rxjava.ext.jdbc with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

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

    Methods in io.vertx.rxjava.ext.mongo that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Observable<JsonArray>` | MongoClient.`distinctObservable(String collection, String fieldName, String resultClassname)` Deprecated. use `MongoClient.rxDistinct(java.lang.String, java.lang.String, java.lang.String)` instead
    `Observable<JsonArray>` | MongoService.`distinctObservable(String collection, String fieldName, String resultClassname)` Deprecated.
    `Observable<JsonArray>` | MongoClient.`distinctWithQueryObservable(String collection, String fieldName, String resultClassname, JsonObject query)` Deprecated. use `MongoClient.rxDistinctWithQuery(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.json.JsonObject)` instead
    `Observable<JsonArray>` | MongoService.`distinctWithQueryObservable(String collection, String fieldName, String resultClassname, JsonObject query)` Deprecated.
    `Observable<JsonArray>` | MongoClient.`listIndexesObservable(String collection)` Deprecated. use `MongoClient.rxListIndexes(java.lang.String)` instead
    `Observable<JsonArray>` | MongoService.`listIndexesObservable(String collection)` Deprecated.
    `Single<JsonArray>` | MongoClient.`rxDistinct(String collection, String fieldName, String resultClassname)` Gets the distinct values of the specified field name.
    `Single<JsonArray>` | MongoService.`rxDistinct(String collection, String fieldName, String resultClassname)`
    `Single<JsonArray>` | MongoClient.`rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Gets the distinct values of the specified field name filtered by specified query.
    `Single<JsonArray>` | MongoService.`rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)`
    `Single<JsonArray>` | MongoClient.`rxListIndexes(String collection)` Get all the indexes in this collection.
    `Single<JsonArray>` | MongoService.`rxListIndexes(String collection)`

    Methods in io.vertx.rxjava.ext.mongo with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonObject>` | MongoClient.`aggregate(String collection, JsonArray pipeline)` Run aggregate MongoDB command with default `AggregateOptions`.
    `ReadStream<JsonObject>` | MongoClient.`aggregateWithOptions(String collection, JsonArray pipeline, AggregateOptions options)` Run aggregate MongoDB command.

    Method parameters in io.vertx.rxjava.ext.mongo with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`

  - ### Uses of JsonArray in io.vertx.rxjava.ext.sql

    Methods in io.vertx.rxjava.ext.sql that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonArray>` | SQLRowStream.`fetch(long amount)` Fetch the specified `amount` of elements.
    `Pipe<JsonArray>` | SQLRowStream.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Observable<JsonArray>` | SQLConnection.`querySingleObservable(String sql)` Deprecated. use `SQLConnection.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | SQLClient.`querySingleObservable(String sql)` Deprecated. use `SQLClient.rxQuerySingle(java.lang.String)` instead
    `Observable<JsonArray>` | SQLConnection.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `SQLConnection.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | SQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `SQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<JsonArray>` | SQLConnection.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | SQLClient.`rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | SQLConnection.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | SQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Observable<JsonArray>` | SQLRowStream.`toObservable()`

    Methods in io.vertx.rxjava.ext.sql with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Observable<ResultSet>` | SQLConnection.`callWithParamsObservable(String sql, JsonArray params, JsonArray outputs)` Deprecated. use `SQLConnection.rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray)` instead
    `Observable<ResultSet>` | SQLClient.`callWithParamsObservable(String sql, JsonArray params, JsonArray outputs)` Deprecated. use `SQLClient.rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray)` instead
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Observable<JsonArray>` | SQLConnection.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `SQLConnection.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<JsonArray>` | SQLClient.`querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `SQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Observable<SQLRowStream>` | SQLConnection.`queryStreamWithParamsObservable(String sql, JsonArray params)` Deprecated. use `SQLConnection.rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<SQLRowStream>` | SQLClient.`queryStreamWithParamsObservable(String sql, JsonArray params)` Deprecated. use `SQLClient.rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Observable<ResultSet>` | SQLConnection.`queryWithParamsObservable(String sql, JsonArray params)` Deprecated. use `SQLConnection.rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<ResultSet>` | SQLClient.`queryWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `SQLClient.rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Single<ResultSet>` | SQLConnection.`rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Single<ResultSet>` | SQLClient.`rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Single<JsonArray>` | SQLConnection.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<JsonArray>` | SQLClient.`rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<SQLRowStream>` | SQLConnection.`rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<SQLRowStream>` | SQLClient.`rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<ResultSet>` | SQLConnection.`rxQueryWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Single<ResultSet>` | SQLClient.`rxQueryWithParams(String sql, JsonArray arguments)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `Single<UpdateResult>` | SQLConnection.`rxUpdateWithParams(String sql, JsonArray params)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `Single<UpdateResult>` | SQLClient.`rxUpdateWithParams(String sql, JsonArray params)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `Observable<UpdateResult>` | SQLConnection.`updateWithParamsObservable(String sql, JsonArray params)` Deprecated. use `SQLConnection.rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `Observable<UpdateResult>` | SQLClient.`updateWithParamsObservable(String sql, JsonArray params)` Deprecated. use `SQLClient.rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead

    Method parameters in io.vertx.rxjava.ext.sql with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `Observable<List<Integer>>` | SQLConnection.`batchCallableWithParamsObservable(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Deprecated. use `SQLConnection.rxBatchCallableWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>, java.util.List<io.vertx.core.json.JsonArray>)` instead
    `Observable<List<Integer>>` | SQLConnection.`batchCallableWithParamsObservable(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Deprecated. use `SQLConnection.rxBatchCallableWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>, java.util.List<io.vertx.core.json.JsonArray>)` instead
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `Observable<List<Integer>>` | SQLConnection.`batchWithParamsObservable(String sqlStatement, List<JsonArray> args)` Deprecated. use `SQLConnection.rxBatchWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>)` instead
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst)` Like `ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)` but with no completion handler.
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Observable<Void>` | SQLRowStream.`pipeToObservable(WriteStream<JsonArray> dst)` Deprecated. use `SQLRowStream.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.core.json.JsonArray>)` instead
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<List<Integer>>` | SQLConnection.`rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `Single<List<Integer>>` | SQLConnection.`rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `Single<List<Integer>>` | SQLConnection.`rxBatchWithParams(String sqlStatement, List<JsonArray> args)` Batch a prepared statement with all entries from the args list.
    `Single<Void>` | SQLRowStream.`rxPipeTo(WriteStream<JsonArray> dst)` Pipe this `ReadStream` to the `WriteStream`.

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

    Methods in io.vertx.rxjava.ext.web that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RoutingContext.`getBodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.rxjava.ext.web.api

    Methods in io.vertx.rxjava.ext.web.api that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | RequestParameter.`getJsonArray()` Returns null if value is not a JsonArray, otherwise it returns value

  - ### Uses of JsonArray in io.vertx.rxjava.ext.web.client

    Methods in io.vertx.rxjava.ext.web.client that return JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `JsonArray` | HttpResponse.`bodyAsJsonArray()`

  - ### Uses of JsonArray in io.vertx.rxjava.ext.web.codec

    Methods in io.vertx.rxjava.ext.web.codec that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static BodyCodec<JsonArray>` | BodyCodec.`jsonArray()`

  - ### Uses of JsonArray in io.vertx.rxjava.redis

    Methods in io.vertx.rxjava.redis that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Observable<JsonArray>` | RedisClient.`bitfieldObservable(String key, BitFieldOptions bitFieldOptions)` Deprecated. use `RedisClient.rxBitfield(java.lang.String, io.vertx.redis.op.BitFieldOptions)` instead
    `Observable<JsonArray>` | RedisClient.`bitfieldWithOverflowObservable(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Deprecated. use `RedisClient.rxBitfieldWithOverflow(java.lang.String, io.vertx.redis.op.BitFieldOptions, io.vertx.redis.op.BitFieldOverflowOptions)` instead
    `Observable<JsonArray>` | RedisClient.`blpopManyObservable(List<String> keys, int seconds)` Deprecated. use `RedisClient.rxBlpopMany(java.util.List<java.lang.String>, int)` instead
    `Observable<JsonArray>` | RedisClient.`blpopObservable(String key, int seconds)` Deprecated. use `RedisClient.rxBlpop(java.lang.String, int)` instead
    `Observable<JsonArray>` | RedisClient.`brpopManyObservable(List<String> keys, int seconds)` Deprecated. use `RedisClient.rxBrpopMany(java.util.List<java.lang.String>, int)` instead
    `Observable<JsonArray>` | RedisClient.`brpopObservable(String key, int seconds)` Deprecated. use `RedisClient.rxBrpop(java.lang.String, int)` instead
    `Observable<JsonArray>` | RedisClient.`clusterGetkeysinslotObservable(long slot, long count)` Deprecated. use `RedisClient.rxClusterGetkeysinslot(long, long)` instead
    `Observable<JsonArray>` | RedisClient.`clusterInfoObservable()` Deprecated. use `RedisClient.rxClusterInfo()` instead
    `Observable<JsonArray>` | RedisClient.`clusterNodesObservable()` Deprecated. use `RedisClient.rxClusterNodes()` instead
    `Observable<JsonArray>` | RedisClient.`clusterSlavesObservable(String nodeId)` Deprecated. use `RedisClient.rxClusterSlaves(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`clusterSlotsObservable()` Deprecated. use `RedisClient.rxClusterSlots()` instead
    `Observable<JsonArray>` | RedisClient.`commandGetkeysObservable()` Deprecated. use `RedisClient.rxCommandGetkeys()` instead
    `Observable<JsonArray>` | RedisClient.`commandInfoObservable(List<String> commands)` Deprecated. use `RedisClient.rxCommandInfo(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`commandObservable()` Deprecated. use `RedisClient.rxCommand()` instead
    `Observable<JsonArray>` | RedisClient.`configGetObservable(String parameter)` Deprecated. use `RedisClient.rxConfigGet(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`evalObservable(String script, List<String> keys, List<String> args)` Deprecated. use `RedisClient.rxEval(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`evalScriptObservable(Script script, List<String> keys, List<String> args)` Deprecated. use `RedisClient.rxEvalScript(io.vertx.rxjava.redis.Script, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`evalshaObservable(String sha1, List<String> keys, List<String> values)` Deprecated. use `RedisClient.rxEvalsha(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisTransaction.`execObservable()` Deprecated. use `RedisTransaction.rxExec()` instead
    `Observable<JsonArray>` | RedisClient.`geohashManyObservable(String key, List<String> members)` Deprecated. use `RedisClient.rxGeohashMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`geohashObservable(String key, String member)` Deprecated. use `RedisClient.rxGeohash(java.lang.String, java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`geoposManyObservable(String key, List<String> members)` Deprecated. use `RedisClient.rxGeoposMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`geoposObservable(String key, String member)` Deprecated. use `RedisClient.rxGeopos(java.lang.String, java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`georadiusbymemberObservable(String key, String member, double radius, GeoUnit unit)` Deprecated. use `RedisClient.rxGeoradiusbymember(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit)` instead
    `Observable<JsonArray>` | RedisClient.`georadiusbymemberWithOptionsObservable(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` Deprecated. use `RedisClient.rxGeoradiusbymemberWithOptions(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
    `Observable<JsonArray>` | RedisClient.`georadiusObservable(String key, double longitude, double latitude, double radius, GeoUnit unit)` Deprecated. use `RedisClient.rxGeoradius(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit)` instead
    `Observable<JsonArray>` | RedisClient.`georadiusWithOptionsObservable(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Deprecated. use `RedisClient.rxGeoradiusWithOptions(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
    `Observable<JsonArray>` | RedisClient.`hkeysObservable(String key)` Deprecated. use `RedisClient.rxHkeys(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`hmgetObservable(String key, List<String> fields)` Deprecated. use `RedisClient.rxHmget(java.lang.String, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`hscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `RedisClient.rxHscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `Observable<JsonArray>` | RedisClient.`hvalsObservable(String key)` Deprecated. use `RedisClient.rxHvals(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`keysObservable(String pattern)` Deprecated. use `RedisClient.rxKeys(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`lrangeObservable(String key, long from, long to)` Deprecated. use `RedisClient.rxLrange(java.lang.String, long, long)` instead
    `Observable<JsonArray>` | RedisClient.`mgetManyObservable(List<String> keys)` Deprecated. use `RedisClient.rxMgetMany(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`mgetObservable(String key)` Deprecated. use `RedisClient.rxMget(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`psubscribeManyObservable(List<String> patterns)` Deprecated. use `RedisClient.rxPsubscribeMany(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`psubscribeObservable(String pattern)` Deprecated. use `RedisClient.rxPsubscribe(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`pubsubChannelsObservable(String pattern)` Deprecated. use `RedisClient.rxPubsubChannels(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`pubsubNumsubObservable(List<String> channels)` Deprecated. use `RedisClient.rxPubsubNumsub(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`roleObservable()` Deprecated. use `RedisClient.rxRole()` instead
    `Single<JsonArray>` | RedisClient.`rxBitfield(String key, BitFieldOptions bitFieldOptions)` Perform arbitrary bitfield integer operations on strings.
    `Single<JsonArray>` | RedisClient.`rxBitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Perform arbitrary bitfield integer operations on strings.
    `Single<JsonArray>` | RedisClient.`rxBlpop(String key, int seconds)` Remove and get the first element in a list, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBlpopMany(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBrpop(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxBrpopMany(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `Single<JsonArray>` | RedisClient.`rxClusterGetkeysinslot(long slot, long count)` Return local key names in the specified hash slot.
    `Single<JsonArray>` | RedisClient.`rxClusterInfo()` Provides info about Redis Cluster node state.
    `Single<JsonArray>` | RedisClient.`rxClusterNodes()` Get Cluster config for the node.
    `Single<JsonArray>` | RedisClient.`rxClusterSlaves(String nodeId)` List slave nodes of the specified master node.
    `Single<JsonArray>` | RedisClient.`rxClusterSlots()` Get array of Cluster slot to node mappings
    `Single<JsonArray>` | RedisClient.`rxCommand()` Get array of Redis command details
    `Single<JsonArray>` | RedisClient.`rxCommandGetkeys()` Extract keys given a full Redis command
    `Single<JsonArray>` | RedisClient.`rxCommandInfo(List<String> commands)` Get array of specific Redis command details
    `Single<JsonArray>` | RedisClient.`rxConfigGet(String parameter)` Get the value of a configuration parameter
    `Single<JsonArray>` | RedisClient.`rxEval(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisClient.`rxEvalScript(Script script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisClient.`rxEvalsha(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `Single<JsonArray>` | RedisTransaction.`rxExec()` Execute all commands issued after MULTI
    `Single<JsonArray>` | RedisClient.`rxGeohash(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<JsonArray>` | RedisClient.`rxGeohashMany(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<JsonArray>` | RedisClient.`rxGeopos(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<JsonArray>` | RedisClient.`rxGeoposMany(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<JsonArray>` | RedisClient.`rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<JsonArray>` | RedisClient.`rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<JsonArray>` | RedisClient.`rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<JsonArray>` | RedisClient.`rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<JsonArray>` | RedisClient.`rxHkeys(String key)` Get all the fields in a hash
    `Single<JsonArray>` | RedisClient.`rxHmget(String key, List<String> fields)` Get the values of all the given hash fields
    `Single<JsonArray>` | RedisClient.`rxHscan(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
    `Single<JsonArray>` | RedisClient.`rxHvals(String key)` Get all the values in a hash
    `Single<JsonArray>` | RedisClient.`rxKeys(String pattern)` Find all keys matching the given pattern
    `Single<JsonArray>` | RedisClient.`rxLrange(String key, long from, long to)` Get a range of elements from a list
    `Single<JsonArray>` | RedisClient.`rxMget(String key)` Get the value of the given key
    `Single<JsonArray>` | RedisClient.`rxMgetMany(List<String> keys)` Get the values of all the given keys
    `Single<JsonArray>` | RedisClient.`rxPsubscribe(String pattern)` Listen for messages published to channels matching the given pattern
    `Single<JsonArray>` | RedisClient.`rxPsubscribeMany(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `Single<JsonArray>` | RedisClient.`rxPubsubChannels(String pattern)` Lists the currently active channels - only those matching the pattern
    `Single<JsonArray>` | RedisClient.`rxPubsubNumsub(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `Single<JsonArray>` | RedisClient.`rxRole()` Return the role of the instance in the context of replication
    `Single<JsonArray>` | RedisClient.`rxScan(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `Single<JsonArray>` | RedisClient.`rxScriptExists(String script)` Check existence of script in the script cache.
    `Single<JsonArray>` | RedisClient.`rxScriptExistsMany(List<String> scripts)` Check existence of scripts in the script cache.
    `Single<JsonArray>` | RedisClient.`rxSdiff(String key, List<String> cmpkeys)` Subtract multiple sets
    `Single<JsonArray>` | RedisClient.`rxSinter(List<String> keys)` Intersect multiple sets
    `Single<JsonArray>` | RedisClient.`rxSlowlogGet(int limit)` Read the Redis slow queries log
    `Single<JsonArray>` | RedisTransaction.`rxSmembers(String key)` Get all the members in a set
    `Single<JsonArray>` | RedisClient.`rxSmembers(String key)` Get all the members in a set
    `Single<JsonArray>` | RedisClient.`rxSort(String key, SortOptions options)` Sort the elements in a list, set or sorted set
    `Single<JsonArray>` | RedisClient.`rxSpopMany(String key, int count)` Remove and return random members from a set
    `Single<JsonArray>` | RedisClient.`rxSrandmemberCount(String key, int count)` Get one or multiple random members from a set
    `Single<JsonArray>` | RedisClient.`rxSscan(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `Single<JsonArray>` | RedisClient.`rxSubscribe(String channel)` Listen for messages published to the given channels
    `Single<JsonArray>` | RedisClient.`rxSubscribeMany(List<String> channels)` Listen for messages published to the given channels
    `Single<JsonArray>` | RedisClient.`rxSunion(List<String> keys)` Add multiple sets
    `Single<JsonArray>` | RedisClient.`rxTime()` Return the current server time
    `Single<JsonArray>` | RedisClient.`rxZrange(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `Single<JsonArray>` | RedisClient.`rxZrangebylex(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
    `Single<JsonArray>` | RedisClient.`rxZrangebyscore(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `Single<JsonArray>` | RedisClient.`rxZrangeWithOptions(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
    `Single<JsonArray>` | RedisClient.`rxZrevrange(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZrevrangebylex(String key, String max, String min, LimitOptions options)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `Single<JsonArray>` | RedisClient.`rxZscan(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores
    `Observable<JsonArray>` | RedisClient.`scanObservable(String cursor, ScanOptions options)` Deprecated. use `RedisClient.rxScan(java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `Observable<JsonArray>` | RedisClient.`scriptExistsManyObservable(List<String> scripts)` Deprecated. use `RedisClient.rxScriptExistsMany(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`scriptExistsObservable(String script)` Deprecated. use `RedisClient.rxScriptExists(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`sdiffObservable(String key, List<String> cmpkeys)` Deprecated. use `RedisClient.rxSdiff(java.lang.String, java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`sinterObservable(List<String> keys)` Deprecated. use `RedisClient.rxSinter(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`slowlogGetObservable(int limit)` Deprecated. use `RedisClient.rxSlowlogGet(int)` instead
    `Observable<JsonArray>` | RedisTransaction.`smembersObservable(String key)` Deprecated. use `RedisTransaction.rxSmembers(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`smembersObservable(String key)` Deprecated. use `RedisClient.rxSmembers(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`sortObservable(String key, SortOptions options)` Deprecated. use `RedisClient.rxSort(java.lang.String, io.vertx.redis.op.SortOptions)` instead
    `Observable<JsonArray>` | RedisClient.`spopManyObservable(String key, int count)` Deprecated. use `RedisClient.rxSpopMany(java.lang.String, int)` instead
    `Observable<JsonArray>` | RedisClient.`srandmemberCountObservable(String key, int count)` Deprecated. use `RedisClient.rxSrandmemberCount(java.lang.String, int)` instead
    `Observable<JsonArray>` | RedisClient.`sscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `RedisClient.rxSscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `Observable<JsonArray>` | RedisClient.`subscribeManyObservable(List<String> channels)` Deprecated. use `RedisClient.rxSubscribeMany(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`subscribeObservable(String channel)` Deprecated. use `RedisClient.rxSubscribe(java.lang.String)` instead
    `Observable<JsonArray>` | RedisClient.`sunionObservable(List<String> keys)` Deprecated. use `RedisClient.rxSunion(java.util.List<java.lang.String>)` instead
    `Observable<JsonArray>` | RedisClient.`timeObservable()` Deprecated. use `RedisClient.rxTime()` instead
    `Observable<JsonArray>` | RedisClient.`zrangebylexObservable(String key, String min, String max, LimitOptions options)` Deprecated. use `RedisClient.rxZrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zrangebyscoreObservable(String key, String min, String max, RangeLimitOptions options)` Deprecated. use `RedisClient.rxZrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zrangeObservable(String key, long start, long stop)` Deprecated. use `RedisClient.rxZrange(java.lang.String, long, long)` instead
    `Observable<JsonArray>` | RedisClient.`zrangeWithOptionsObservable(String key, long start, long stop, RangeOptions options)` Deprecated. use `RedisClient.rxZrangeWithOptions(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zrevrangebylexObservable(String key, String max, String min, LimitOptions options)` Deprecated. use `RedisClient.rxZrevrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zrevrangebyscoreObservable(String key, String max, String min, RangeLimitOptions options)` Deprecated. use `RedisClient.rxZrevrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zrevrangeObservable(String key, long start, long stop, RangeOptions options)` Deprecated. use `RedisClient.rxZrevrange(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
    `Observable<JsonArray>` | RedisClient.`zscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `RedisClient.rxZscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead

    Method parameters in io.vertx.rxjava.redis with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores

  - ### Uses of JsonArray in io.vertx.rxjava.redis.sentinel

    Methods in io.vertx.rxjava.redis.sentinel that return types with arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `Observable<JsonArray>` | RedisSentinel.`getMasterAddrByNameObservable(String name)` Deprecated. use `RedisSentinel.rxGetMasterAddrByName(java.lang.String)` instead
    `Observable<JsonArray>` | RedisSentinel.`masterObservable(String name)` Deprecated. use `RedisSentinel.rxMaster(java.lang.String)` instead
    `Observable<JsonArray>` | RedisSentinel.`mastersObservable()` Deprecated. use `RedisSentinel.rxMasters()` instead
    `Single<JsonArray>` | RedisSentinel.`rxGetMasterAddrByName(String name)` Return the ip and port number of the master with that name.
    `Single<JsonArray>` | RedisSentinel.`rxMaster(String name)` Show the state and info of the specified master
    `Single<JsonArray>` | RedisSentinel.`rxMasters()` Show a list of monitored masters and their state
    `Single<JsonArray>` | RedisSentinel.`rxSentinels(String name)` Show a list of sentinel instances for this master, and their state
    `Single<JsonArray>` | RedisSentinel.`rxSlaves(String name)` Show a list of slaves for this master, and their state
    `Observable<JsonArray>` | RedisSentinel.`sentinelsObservable(String name)` Deprecated. use `RedisSentinel.rxSentinels(java.lang.String)` instead
    `Observable<JsonArray>` | RedisSentinel.`slavesObservable(String name)` Deprecated. use `RedisSentinel.rxSlaves(java.lang.String)` instead

    Method parameters in io.vertx.rxjava.redis.sentinel with type arguments of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of slaves for this master, and their state

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

    Methods in io.vertx.serviceproxy with parameters of type JsonArray
    Modifier and Type | Method and Description
    --- | ---
    `static List<Character>` | ProxyUtils.`convertToListChar(JsonArray arr)`
    `static Set<Character>` | ProxyUtils.`convertToSetChar(JsonArray arr)`

Copyright © 2019 Eclipse. All rights reserved.