Uses of Class
redis.clients.jedis.Response

Packages that use Response

Package	Description
redis.clients.jedis
redis.clients.jedis.bloom.commands	This package contains the interfaces that contain methods representing RedisBloom commands.
redis.clients.jedis.commands	This package contains the interfaces that contain methods representing Redis core commands.
redis.clients.jedis.graph	This package contains the classes and interfaces related to RedisGraph module.
redis.clients.jedis.json	This package contains the classes and interfaces related to RedisJSON module.
redis.clients.jedis.search	This package contains the classes and interfaces related to RediSearch module.
redis.clients.jedis.timeseries	This package contains the classes and interfaces related to RedisTimeSeries module.

Uses of Response in redis.clients.jedis

Fields in redis.clients.jedis declared as Response

Modifier and Type	Field	Description
private Response<?>	Response.dependency

Fields in redis.clients.jedis with type parameters of type Response

Modifier and Type	Field	Description
private final Map<HostAndPort,Queue<Response<?>>>	MultiNodePipelineBase.pipelinedResponses
private final Queue<Response<?>>	Queable.pipelinedResponses	Deprecated.

Methods in redis.clients.jedis that return Response

Modifier and Type	Method	Description
Response<Long>	MultiNodePipelineBase.append(byte[] key, byte[] value)
Response<Long>	MultiNodePipelineBase.append(String key, String value)
Response<Long>	Pipeline.append(byte[] key, byte[] value)
Response<Long>	Pipeline.append(String key, String value)
Response<Long>	TransactionBase.append(byte[] key, byte[] value)
Response<Long>	TransactionBase.append(String key, String value)
protected final <T> Response<T>	MultiNodePipelineBase.appendCommand(CommandObject<T> commandObject)
final <T> Response<T>	Pipeline.appendCommand(CommandObject<T> commandObject)
protected final <T> Response<T>	TransactionBase.appendCommand(CommandObject<T> commandObject)
Response<Boolean>	MultiNodePipelineBase.bfAdd(String key, String item)
Response<Boolean>	Pipeline.bfAdd(String key, String item)
Response<Boolean>	TransactionBase.bfAdd(String key, String item)
Response<Long>	MultiNodePipelineBase.bfCard(String key)
Response<Long>	Pipeline.bfCard(String key)
Response<Long>	TransactionBase.bfCard(String key)
Response<Boolean>	MultiNodePipelineBase.bfExists(String key, String item)
Response<Boolean>	Pipeline.bfExists(String key, String item)
Response<Boolean>	TransactionBase.bfExists(String key, String item)
Response<Map<String,Object>>	MultiNodePipelineBase.bfInfo(String key)
Response<Map<String,Object>>	Pipeline.bfInfo(String key)
Response<Map<String,Object>>	TransactionBase.bfInfo(String key)
Response<List<Boolean>>	MultiNodePipelineBase.bfInsert(String key, String... items)
Response<List<Boolean>>	MultiNodePipelineBase.bfInsert(String key, BFInsertParams insertParams, String... items)
Response<List<Boolean>>	Pipeline.bfInsert(String key, String... items)
Response<List<Boolean>>	Pipeline.bfInsert(String key, BFInsertParams insertParams, String... items)
Response<List<Boolean>>	TransactionBase.bfInsert(String key, String... items)
Response<List<Boolean>>	TransactionBase.bfInsert(String key, BFInsertParams insertParams, String... items)
Response<String>	MultiNodePipelineBase.bfLoadChunk(String key, long iterator, byte[] data)
Response<String>	Pipeline.bfLoadChunk(String key, long iterator, byte[] data)
Response<String>	TransactionBase.bfLoadChunk(String key, long iterator, byte[] data)
Response<List<Boolean>>	MultiNodePipelineBase.bfMAdd(String key, String... items)
Response<List<Boolean>>	Pipeline.bfMAdd(String key, String... items)
Response<List<Boolean>>	TransactionBase.bfMAdd(String key, String... items)
Response<List<Boolean>>	MultiNodePipelineBase.bfMExists(String key, String... items)
Response<List<Boolean>>	Pipeline.bfMExists(String key, String... items)
Response<List<Boolean>>	TransactionBase.bfMExists(String key, String... items)
Response<String>	MultiNodePipelineBase.bfReserve(String key, double errorRate, long capacity)
Response<String>	MultiNodePipelineBase.bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
Response<String>	Pipeline.bfReserve(String key, double errorRate, long capacity)
Response<String>	Pipeline.bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
Response<String>	TransactionBase.bfReserve(String key, double errorRate, long capacity)
Response<String>	TransactionBase.bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
Response<Map.Entry<Long,byte[]>>	MultiNodePipelineBase.bfScanDump(String key, long iterator)
Response<Map.Entry<Long,byte[]>>	Pipeline.bfScanDump(String key, long iterator)
Response<Map.Entry<Long,byte[]>>	TransactionBase.bfScanDump(String key, long iterator)
Response<Long>	MultiNodePipelineBase.bitcount(byte[] key)
Response<Long>	MultiNodePipelineBase.bitcount(byte[] key, long start, long end)
Response<Long>	MultiNodePipelineBase.bitcount(byte[] key, long start, long end, BitCountOption option)
Response<Long>	MultiNodePipelineBase.bitcount(String key)
Response<Long>	MultiNodePipelineBase.bitcount(String key, long start, long end)
Response<Long>	MultiNodePipelineBase.bitcount(String key, long start, long end, BitCountOption option)
Response<Long>	Pipeline.bitcount(byte[] key)
Response<Long>	Pipeline.bitcount(byte[] key, long start, long end)
Response<Long>	Pipeline.bitcount(byte[] key, long start, long end, BitCountOption option)
Response<Long>	Pipeline.bitcount(String key)
Response<Long>	Pipeline.bitcount(String key, long start, long end)
Response<Long>	Pipeline.bitcount(String key, long start, long end, BitCountOption option)
Response<Long>	TransactionBase.bitcount(byte[] key)
Response<Long>	TransactionBase.bitcount(byte[] key, long start, long end)
Response<Long>	TransactionBase.bitcount(byte[] key, long start, long end, BitCountOption option)
Response<Long>	TransactionBase.bitcount(String key)
Response<Long>	TransactionBase.bitcount(String key, long start, long end)
Response<Long>	TransactionBase.bitcount(String key, long start, long end, BitCountOption option)
Response<List<Long>>	MultiNodePipelineBase.bitfield(byte[] key, byte[]... arguments)
Response<List<Long>>	MultiNodePipelineBase.bitfield(String key, String... arguments)
Response<List<Long>>	Pipeline.bitfield(byte[] key, byte[]... arguments)
Response<List<Long>>	Pipeline.bitfield(String key, String... arguments)
Response<List<Long>>	TransactionBase.bitfield(byte[] key, byte[]... arguments)
Response<List<Long>>	TransactionBase.bitfield(String key, String... arguments)
Response<List<Long>>	MultiNodePipelineBase.bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	MultiNodePipelineBase.bitfieldReadonly(String key, String... arguments)
Response<List<Long>>	Pipeline.bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	Pipeline.bitfieldReadonly(String key, String... arguments)
Response<List<Long>>	TransactionBase.bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	TransactionBase.bitfieldReadonly(String key, String... arguments)
Response<Long>	MultiNodePipelineBase.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	MultiNodePipelineBase.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	Pipeline.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	Pipeline.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	TransactionBase.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	TransactionBase.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	MultiNodePipelineBase.bitpos(byte[] key, boolean value)
Response<Long>	MultiNodePipelineBase.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	MultiNodePipelineBase.bitpos(String key, boolean value)
Response<Long>	MultiNodePipelineBase.bitpos(String key, boolean value, BitPosParams params)
Response<Long>	Pipeline.bitpos(byte[] key, boolean value)
Response<Long>	Pipeline.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	Pipeline.bitpos(String key, boolean value)
Response<Long>	Pipeline.bitpos(String key, boolean value, BitPosParams params)
Response<Long>	TransactionBase.bitpos(byte[] key, boolean value)
Response<Long>	TransactionBase.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	TransactionBase.bitpos(String key, boolean value)
Response<Long>	TransactionBase.bitpos(String key, boolean value, BitPosParams params)
Response<byte[]>	MultiNodePipelineBase.blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
Response<String>	MultiNodePipelineBase.blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
Response<byte[]>	Pipeline.blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
Response<String>	Pipeline.blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
Response<byte[]>	TransactionBase.blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
Response<String>	TransactionBase.blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
Response<KeyValue<byte[],List<byte[]>>>	MultiNodePipelineBase.blmpop(long timeout, ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	MultiNodePipelineBase.blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	MultiNodePipelineBase.blmpop(long timeout, ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	MultiNodePipelineBase.blmpop(long timeout, ListDirection direction, String... keys)
Response<KeyValue<byte[],List<byte[]>>>	Pipeline.blmpop(long timeout, ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	Pipeline.blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	Pipeline.blmpop(long timeout, ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	Pipeline.blmpop(long timeout, ListDirection direction, String... keys)
Response<KeyValue<byte[],List<byte[]>>>	TransactionBase.blmpop(long timeout, ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	TransactionBase.blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	TransactionBase.blmpop(long timeout, ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	TransactionBase.blmpop(long timeout, ListDirection direction, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.blpop(double timeout, byte[]... keys)
Response<KeyedListElement>	MultiNodePipelineBase.blpop(double timeout, String key)
Response<KeyedListElement>	MultiNodePipelineBase.blpop(double timeout, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.blpop(int timeout, byte[]... keys)
Response<List<String>>	MultiNodePipelineBase.blpop(int timeout, String key)
Response<List<String>>	MultiNodePipelineBase.blpop(int timeout, String... keys)
Response<List<byte[]>>	Pipeline.blpop(double timeout, byte[]... keys)
Response<KeyedListElement>	Pipeline.blpop(double timeout, String key)
Response<KeyedListElement>	Pipeline.blpop(double timeout, String... keys)
Response<List<byte[]>>	Pipeline.blpop(int timeout, byte[]... keys)
Response<List<String>>	Pipeline.blpop(int timeout, String key)
Response<List<String>>	Pipeline.blpop(int timeout, String... keys)
Response<List<byte[]>>	TransactionBase.blpop(double timeout, byte[]... keys)
Response<KeyedListElement>	TransactionBase.blpop(double timeout, String key)
Response<KeyedListElement>	TransactionBase.blpop(double timeout, String... keys)
Response<List<byte[]>>	TransactionBase.blpop(int timeout, byte[]... keys)
Response<List<String>>	TransactionBase.blpop(int timeout, String key)
Response<List<String>>	TransactionBase.blpop(int timeout, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.brpop(double timeout, byte[]... keys)
Response<KeyedListElement>	MultiNodePipelineBase.brpop(double timeout, String key)
Response<KeyedListElement>	MultiNodePipelineBase.brpop(double timeout, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.brpop(int timeout, byte[]... keys)
Response<List<String>>	MultiNodePipelineBase.brpop(int timeout, String key)
Response<List<String>>	MultiNodePipelineBase.brpop(int timeout, String... keys)
Response<List<byte[]>>	Pipeline.brpop(double timeout, byte[]... keys)
Response<KeyedListElement>	Pipeline.brpop(double timeout, String key)
Response<KeyedListElement>	Pipeline.brpop(double timeout, String... keys)
Response<List<byte[]>>	Pipeline.brpop(int timeout, byte[]... keys)
Response<List<String>>	Pipeline.brpop(int timeout, String key)
Response<List<String>>	Pipeline.brpop(int timeout, String... keys)
Response<List<byte[]>>	TransactionBase.brpop(double timeout, byte[]... keys)
Response<KeyedListElement>	TransactionBase.brpop(double timeout, String key)
Response<KeyedListElement>	TransactionBase.brpop(double timeout, String... keys)
Response<List<byte[]>>	TransactionBase.brpop(int timeout, byte[]... keys)
Response<List<String>>	TransactionBase.brpop(int timeout, String key)
Response<List<String>>	TransactionBase.brpop(int timeout, String... keys)
Response<byte[]>	MultiNodePipelineBase.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	MultiNodePipelineBase.brpoplpush(String source, String destination, int timeout)
Response<byte[]>	Pipeline.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	Pipeline.brpoplpush(String source, String destination, int timeout)
Response<byte[]>	TransactionBase.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	TransactionBase.brpoplpush(String source, String destination, int timeout)
Response<KeyValue<byte[],List<Tuple>>>	MultiNodePipelineBase.bzmpop(long timeout, SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	MultiNodePipelineBase.bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	MultiNodePipelineBase.bzmpop(long timeout, SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	MultiNodePipelineBase.bzmpop(long timeout, SortedSetOption option, String... keys)
Response<KeyValue<byte[],List<Tuple>>>	Pipeline.bzmpop(long timeout, SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	Pipeline.bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	Pipeline.bzmpop(long timeout, SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	Pipeline.bzmpop(long timeout, SortedSetOption option, String... keys)
Response<KeyValue<byte[],List<Tuple>>>	TransactionBase.bzmpop(long timeout, SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	TransactionBase.bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	TransactionBase.bzmpop(long timeout, SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	TransactionBase.bzmpop(long timeout, SortedSetOption option, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.bzpopmax(double timeout, byte[]... keys)
Response<KeyedZSetElement>	MultiNodePipelineBase.bzpopmax(double timeout, String... keys)
Response<List<byte[]>>	Pipeline.bzpopmax(double timeout, byte[]... keys)
Response<KeyedZSetElement>	Pipeline.bzpopmax(double timeout, String... keys)
Response<List<byte[]>>	TransactionBase.bzpopmax(double timeout, byte[]... keys)
Response<KeyedZSetElement>	TransactionBase.bzpopmax(double timeout, String... keys)
Response<List<byte[]>>	MultiNodePipelineBase.bzpopmin(double timeout, byte[]... keys)
Response<KeyedZSetElement>	MultiNodePipelineBase.bzpopmin(double timeout, String... keys)
Response<List<byte[]>>	Pipeline.bzpopmin(double timeout, byte[]... keys)
Response<KeyedZSetElement>	Pipeline.bzpopmin(double timeout, String... keys)
Response<List<byte[]>>	TransactionBase.bzpopmin(double timeout, byte[]... keys)
Response<KeyedZSetElement>	TransactionBase.bzpopmin(double timeout, String... keys)
Response<Boolean>	MultiNodePipelineBase.cfAdd(String key, String item)
Response<Boolean>	Pipeline.cfAdd(String key, String item)
Response<Boolean>	TransactionBase.cfAdd(String key, String item)
Response<Boolean>	MultiNodePipelineBase.cfAddNx(String key, String item)
Response<Boolean>	Pipeline.cfAddNx(String key, String item)
Response<Boolean>	TransactionBase.cfAddNx(String key, String item)
Response<Long>	MultiNodePipelineBase.cfCount(String key, String item)
Response<Long>	Pipeline.cfCount(String key, String item)
Response<Long>	TransactionBase.cfCount(String key, String item)
Response<Boolean>	MultiNodePipelineBase.cfDel(String key, String item)
Response<Boolean>	Pipeline.cfDel(String key, String item)
Response<Boolean>	TransactionBase.cfDel(String key, String item)
Response<Boolean>	MultiNodePipelineBase.cfExists(String key, String item)
Response<Boolean>	Pipeline.cfExists(String key, String item)
Response<Boolean>	TransactionBase.cfExists(String key, String item)
Response<Map<String,Object>>	MultiNodePipelineBase.cfInfo(String key)
Response<Map<String,Object>>	Pipeline.cfInfo(String key)
Response<Map<String,Object>>	TransactionBase.cfInfo(String key)
Response<List<Boolean>>	MultiNodePipelineBase.cfInsert(String key, String... items)
Response<List<Boolean>>	MultiNodePipelineBase.cfInsert(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	Pipeline.cfInsert(String key, String... items)
Response<List<Boolean>>	Pipeline.cfInsert(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	TransactionBase.cfInsert(String key, String... items)
Response<List<Boolean>>	TransactionBase.cfInsert(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	MultiNodePipelineBase.cfInsertNx(String key, String... items)
Response<List<Boolean>>	MultiNodePipelineBase.cfInsertNx(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	Pipeline.cfInsertNx(String key, String... items)
Response<List<Boolean>>	Pipeline.cfInsertNx(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	TransactionBase.cfInsertNx(String key, String... items)
Response<List<Boolean>>	TransactionBase.cfInsertNx(String key, CFInsertParams insertParams, String... items)
Response<String>	MultiNodePipelineBase.cfLoadChunk(String key, long iterator, byte[] data)
Response<String>	Pipeline.cfLoadChunk(String key, long iterator, byte[] data)
Response<String>	TransactionBase.cfLoadChunk(String key, long iterator, byte[] data)
Response<String>	MultiNodePipelineBase.cfReserve(String key, long capacity)
Response<String>	MultiNodePipelineBase.cfReserve(String key, long capacity, CFReserveParams reserveParams)
Response<String>	Pipeline.cfReserve(String key, long capacity)
Response<String>	Pipeline.cfReserve(String key, long capacity, CFReserveParams reserveParams)
Response<String>	TransactionBase.cfReserve(String key, long capacity)
Response<String>	TransactionBase.cfReserve(String key, long capacity, CFReserveParams reserveParams)
Response<Map.Entry<Long,byte[]>>	MultiNodePipelineBase.cfScanDump(String key, long iterator)
Response<Map.Entry<Long,byte[]>>	Pipeline.cfScanDump(String key, long iterator)
Response<Map.Entry<Long,byte[]>>	TransactionBase.cfScanDump(String key, long iterator)
Response<List<Long>>	MultiNodePipelineBase.cmsIncrBy(String key, Map<String,Long> itemIncrements)
Response<List<Long>>	Pipeline.cmsIncrBy(String key, Map<String,Long> itemIncrements)
Response<List<Long>>	TransactionBase.cmsIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	MultiNodePipelineBase.cmsInfo(String key)
Response<Map<String,Object>>	Pipeline.cmsInfo(String key)
Response<Map<String,Object>>	TransactionBase.cmsInfo(String key)
Response<String>	MultiNodePipelineBase.cmsInitByDim(String key, long width, long depth)
Response<String>	Pipeline.cmsInitByDim(String key, long width, long depth)
Response<String>	TransactionBase.cmsInitByDim(String key, long width, long depth)
Response<String>	MultiNodePipelineBase.cmsInitByProb(String key, double error, double probability)
Response<String>	Pipeline.cmsInitByProb(String key, double error, double probability)
Response<String>	TransactionBase.cmsInitByProb(String key, double error, double probability)
Response<String>	MultiNodePipelineBase.cmsMerge(String destKey, String... keys)
Response<String>	MultiNodePipelineBase.cmsMerge(String destKey, Map<String,Long> keysAndWeights)
Response<String>	Pipeline.cmsMerge(String destKey, String... keys)
Response<String>	Pipeline.cmsMerge(String destKey, Map<String,Long> keysAndWeights)
Response<String>	TransactionBase.cmsMerge(String destKey, String... keys)
Response<String>	TransactionBase.cmsMerge(String destKey, Map<String,Long> keysAndWeights)
Response<List<Long>>	MultiNodePipelineBase.cmsQuery(String key, String... items)
Response<List<Long>>	Pipeline.cmsQuery(String key, String... items)
Response<List<Long>>	TransactionBase.cmsQuery(String key, String... items)
Response<Boolean>	MultiNodePipelineBase.copy(byte[] srcKey, byte[] dstKey, boolean replace)
Response<Boolean>	MultiNodePipelineBase.copy(String srcKey, String dstKey, boolean replace)
Response<Boolean>	Pipeline.copy(byte[] srcKey, byte[] dstKey, boolean replace)
Response<Boolean>	Pipeline.copy(byte[] srcKey, byte[] dstKey, int db, boolean replace)
Response<Boolean>	Pipeline.copy(String srcKey, String dstKey, boolean replace)
Response<Boolean>	Pipeline.copy(String srcKey, String dstKey, int db, boolean replace)
Response<Boolean>	TransactionBase.copy(byte[] srcKey, byte[] dstKey, boolean replace)
Response<Boolean>	TransactionBase.copy(String srcKey, String dstKey, boolean replace)
Response<Long>	Pipeline.dbSize()
Response<Long>	MultiNodePipelineBase.decr(byte[] key)
Response<Long>	MultiNodePipelineBase.decr(String key)
Response<Long>	Pipeline.decr(byte[] key)
Response<Long>	Pipeline.decr(String key)
Response<Long>	TransactionBase.decr(byte[] key)
Response<Long>	TransactionBase.decr(String key)
Response<Long>	MultiNodePipelineBase.decrBy(byte[] key, long decrement)
Response<Long>	MultiNodePipelineBase.decrBy(String key, long decrement)
Response<Long>	Pipeline.decrBy(byte[] key, long decrement)
Response<Long>	Pipeline.decrBy(String key, long decrement)
Response<Long>	TransactionBase.decrBy(byte[] key, long decrement)
Response<Long>	TransactionBase.decrBy(String key, long decrement)
Response<Long>	MultiNodePipelineBase.del(byte[] key)
Response<Long>	MultiNodePipelineBase.del(byte[]... keys)
Response<Long>	MultiNodePipelineBase.del(String key)
Response<Long>	MultiNodePipelineBase.del(String... keys)
Response<Long>	Pipeline.del(byte[] key)
Response<Long>	Pipeline.del(byte[]... keys)
Response<Long>	Pipeline.del(String key)
Response<Long>	Pipeline.del(String... keys)
Response<Long>	TransactionBase.del(byte[] key)
Response<Long>	TransactionBase.del(byte[]... keys)
Response<Long>	TransactionBase.del(String key)
Response<Long>	TransactionBase.del(String... keys)
Response<byte[]>	MultiNodePipelineBase.dump(byte[] key)
Response<byte[]>	MultiNodePipelineBase.dump(String key)
Response<byte[]>	Pipeline.dump(byte[] key)
Response<byte[]>	Pipeline.dump(String key)
Response<byte[]>	TransactionBase.dump(byte[] key)
Response<byte[]>	TransactionBase.dump(String key)
protected final <T> Response<T>	Queable.enqueResponse(Builder<T> builder)	Deprecated.
Response<Object>	MultiNodePipelineBase.eval(byte[] script)
Response<Object>	MultiNodePipelineBase.eval(byte[] script, byte[] sampleKey)
Response<Object>	MultiNodePipelineBase.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	MultiNodePipelineBase.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.eval(String script)
Response<Object>	MultiNodePipelineBase.eval(String script, int keyCount, String... params)
Response<Object>	MultiNodePipelineBase.eval(String script, String sampleKey)
Response<Object>	MultiNodePipelineBase.eval(String script, List<String> keys, List<String> args)
Response<Object>	Pipeline.eval(byte[] script)
Response<Object>	Pipeline.eval(byte[] script, byte[] sampleKey)
Response<Object>	Pipeline.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	Pipeline.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.eval(String script)
Response<Object>	Pipeline.eval(String script, int keyCount, String... params)
Response<Object>	Pipeline.eval(String script, String sampleKey)
Response<Object>	Pipeline.eval(String script, List<String> keys, List<String> args)
Response<Object>	TransactionBase.eval(byte[] script)
Response<Object>	TransactionBase.eval(byte[] script, byte[] sampleKey)
Response<Object>	TransactionBase.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	TransactionBase.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.eval(String script)
Response<Object>	TransactionBase.eval(String script, int keyCount, String... params)
Response<Object>	TransactionBase.eval(String script, String sampleKey)
Response<Object>	TransactionBase.eval(String script, List<String> keys, List<String> args)
Response<Object>	MultiNodePipelineBase.evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.evalReadonly(String script, List<String> keys, List<String> args)
Response<Object>	Pipeline.evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.evalReadonly(String script, List<String> keys, List<String> args)
Response<Object>	TransactionBase.evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.evalReadonly(String script, List<String> keys, List<String> args)
Response<Object>	MultiNodePipelineBase.evalsha(byte[] sha1)
Response<Object>	MultiNodePipelineBase.evalsha(byte[] sha1, byte[] sampleKey)
Response<Object>	MultiNodePipelineBase.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	MultiNodePipelineBase.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.evalsha(String sha1)
Response<Object>	MultiNodePipelineBase.evalsha(String sha1, int keyCount, String... params)
Response<Object>	MultiNodePipelineBase.evalsha(String sha1, String sampleKey)
Response<Object>	MultiNodePipelineBase.evalsha(String sha1, List<String> keys, List<String> args)
Response<Object>	Pipeline.evalsha(byte[] sha1)
Response<Object>	Pipeline.evalsha(byte[] sha1, byte[] sampleKey)
Response<Object>	Pipeline.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	Pipeline.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.evalsha(String sha1)
Response<Object>	Pipeline.evalsha(String sha1, int keyCount, String... params)
Response<Object>	Pipeline.evalsha(String sha1, String sampleKey)
Response<Object>	Pipeline.evalsha(String sha1, List<String> keys, List<String> args)
Response<Object>	TransactionBase.evalsha(byte[] sha1)
Response<Object>	TransactionBase.evalsha(byte[] sha1, byte[] sampleKey)
Response<Object>	TransactionBase.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	TransactionBase.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.evalsha(String sha1)
Response<Object>	TransactionBase.evalsha(String sha1, int keyCount, String... params)
Response<Object>	TransactionBase.evalsha(String sha1, String sampleKey)
Response<Object>	TransactionBase.evalsha(String sha1, List<String> keys, List<String> args)
Response<Object>	MultiNodePipelineBase.evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.evalshaReadonly(String sha1, List<String> keys, List<String> args)
Response<Object>	Pipeline.evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.evalshaReadonly(String sha1, List<String> keys, List<String> args)
Response<Object>	TransactionBase.evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.evalshaReadonly(String sha1, List<String> keys, List<String> args)
<T> Response<T>	Pipeline.executeCommand(CommandObject<T> command)
<T> Response<T>	TransactionBase.executeCommand(CommandObject<T> command)
Response<Boolean>	MultiNodePipelineBase.exists(byte[] key)
Response<Long>	MultiNodePipelineBase.exists(byte[]... keys)
Response<Boolean>	MultiNodePipelineBase.exists(String key)
Response<Long>	MultiNodePipelineBase.exists(String... keys)
Response<Boolean>	Pipeline.exists(byte[] key)
Response<Long>	Pipeline.exists(byte[]... keys)
Response<Boolean>	Pipeline.exists(String key)
Response<Long>	Pipeline.exists(String... keys)
Response<Boolean>	TransactionBase.exists(byte[] key)
Response<Long>	TransactionBase.exists(byte[]... keys)
Response<Boolean>	TransactionBase.exists(String key)
Response<Long>	TransactionBase.exists(String... keys)
Response<Long>	MultiNodePipelineBase.expire(byte[] key, long seconds)
Response<Long>	MultiNodePipelineBase.expire(byte[] key, long seconds, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.expire(String key, long seconds)
Response<Long>	MultiNodePipelineBase.expire(String key, long seconds, ExpiryOption expiryOption)
Response<Long>	Pipeline.expire(byte[] key, long seconds)
Response<Long>	Pipeline.expire(byte[] key, long seconds, ExpiryOption expiryOption)
Response<Long>	Pipeline.expire(String key, long seconds)
Response<Long>	Pipeline.expire(String key, long seconds, ExpiryOption expiryOption)
Response<Long>	TransactionBase.expire(byte[] key, long seconds)
Response<Long>	TransactionBase.expire(byte[] key, long seconds, ExpiryOption expiryOption)
Response<Long>	TransactionBase.expire(String key, long seconds)
Response<Long>	TransactionBase.expire(String key, long seconds, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.expireAt(byte[] key, long unixTime)
Response<Long>	MultiNodePipelineBase.expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.expireAt(String key, long unixTime)
Response<Long>	MultiNodePipelineBase.expireAt(String key, long unixTime, ExpiryOption expiryOption)
Response<Long>	Pipeline.expireAt(byte[] key, long unixTime)
Response<Long>	Pipeline.expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
Response<Long>	Pipeline.expireAt(String key, long unixTime)
Response<Long>	Pipeline.expireAt(String key, long unixTime, ExpiryOption expiryOption)
Response<Long>	TransactionBase.expireAt(byte[] key, long unixTime)
Response<Long>	TransactionBase.expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
Response<Long>	TransactionBase.expireAt(String key, long unixTime)
Response<Long>	TransactionBase.expireAt(String key, long unixTime, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.expireTime(byte[] key)
Response<Long>	MultiNodePipelineBase.expireTime(String key)
Response<Long>	Pipeline.expireTime(byte[] key)
Response<Long>	Pipeline.expireTime(String key)
Response<Long>	TransactionBase.expireTime(byte[] key)
Response<Long>	TransactionBase.expireTime(String key)
Response<Object>	MultiNodePipelineBase.fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.fcall(String name, List<String> keys, List<String> args)
Response<Object>	Pipeline.fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.fcall(String name, List<String> keys, List<String> args)
Response<Object>	TransactionBase.fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.fcall(String name, List<String> keys, List<String> args)
Response<Object>	MultiNodePipelineBase.fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	MultiNodePipelineBase.fcallReadonly(String name, List<String> keys, List<String> args)
Response<Object>	Pipeline.fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	Pipeline.fcallReadonly(String name, List<String> keys, List<String> args)
Response<Object>	TransactionBase.fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	TransactionBase.fcallReadonly(String name, List<String> keys, List<String> args)
Response<AggregationResult>	MultiNodePipelineBase.ftAggregate(String indexName, AggregationBuilder aggr)
Response<AggregationResult>	Pipeline.ftAggregate(String indexName, AggregationBuilder aggr)
Response<AggregationResult>	TransactionBase.ftAggregate(String indexName, AggregationBuilder aggr)
Response<String>	MultiNodePipelineBase.ftAliasAdd(String aliasName, String indexName)	Deprecated.
Response<String>	Pipeline.ftAliasAdd(String aliasName, String indexName)	Deprecated.
Response<String>	TransactionBase.ftAliasAdd(String aliasName, String indexName)	Deprecated.
Response<String>	MultiNodePipelineBase.ftAliasDel(String aliasName)	Deprecated.
Response<String>	Pipeline.ftAliasDel(String aliasName)	Deprecated.
Response<String>	TransactionBase.ftAliasDel(String aliasName)	Deprecated.
Response<String>	MultiNodePipelineBase.ftAliasUpdate(String aliasName, String indexName)	Deprecated.
Response<String>	Pipeline.ftAliasUpdate(String aliasName, String indexName)	Deprecated.
Response<String>	TransactionBase.ftAliasUpdate(String aliasName, String indexName)	Deprecated.
Response<String>	MultiNodePipelineBase.ftAlter(String indexName, Iterable<SchemaField> schemaFields)
Response<String>	MultiNodePipelineBase.ftAlter(String indexName, Schema schema)
Response<String>	Pipeline.ftAlter(String indexName, Iterable<SchemaField> schemaFields)
Response<String>	Pipeline.ftAlter(String indexName, Schema schema)
Response<String>	TransactionBase.ftAlter(String indexName, Iterable<SchemaField> schemaFields)
Response<String>	TransactionBase.ftAlter(String indexName, Schema schema)
Response<Map<String,String>>	MultiNodePipelineBase.ftConfigGet(String option)
Response<Map<String,String>>	MultiNodePipelineBase.ftConfigGet(String indexName, String option)
Response<Map<String,String>>	Pipeline.ftConfigGet(String option)
Response<Map<String,String>>	Pipeline.ftConfigGet(String indexName, String option)
Response<Map<String,String>>	TransactionBase.ftConfigGet(String option)
Response<Map<String,String>>	TransactionBase.ftConfigGet(String indexName, String option)
Response<String>	MultiNodePipelineBase.ftConfigSet(String option, String value)
Response<String>	MultiNodePipelineBase.ftConfigSet(String indexName, String option, String value)
Response<String>	Pipeline.ftConfigSet(String option, String value)
Response<String>	Pipeline.ftConfigSet(String indexName, String option, String value)
Response<String>	TransactionBase.ftConfigSet(String option, String value)
Response<String>	TransactionBase.ftConfigSet(String indexName, String option, String value)
Response<String>	MultiNodePipelineBase.ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields)
Response<String>	MultiNodePipelineBase.ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
Response<String>	Pipeline.ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields)
Response<String>	Pipeline.ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
Response<String>	TransactionBase.ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields)
Response<String>	TransactionBase.ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
Response<String>	MultiNodePipelineBase.ftCursorDel(String indexName, long cursorId)	Deprecated.
Response<String>	Pipeline.ftCursorDel(String indexName, long cursorId)	Deprecated.
Response<String>	TransactionBase.ftCursorDel(String indexName, long cursorId)	Deprecated.
Response<AggregationResult>	MultiNodePipelineBase.ftCursorRead(String indexName, long cursorId, int count)	Deprecated.
Response<AggregationResult>	Pipeline.ftCursorRead(String indexName, long cursorId, int count)	Deprecated.
Response<AggregationResult>	TransactionBase.ftCursorRead(String indexName, long cursorId, int count)	Deprecated.
Response<Long>	MultiNodePipelineBase.ftDictAdd(String dictionary, String... terms)
Response<Long>	Pipeline.ftDictAdd(String dictionary, String... terms)
Response<Long>	TransactionBase.ftDictAdd(String dictionary, String... terms)
Response<Long>	MultiNodePipelineBase.ftDictAddBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	Pipeline.ftDictAddBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	TransactionBase.ftDictAddBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	MultiNodePipelineBase.ftDictDel(String dictionary, String... terms)
Response<Long>	Pipeline.ftDictDel(String dictionary, String... terms)
Response<Long>	TransactionBase.ftDictDel(String dictionary, String... terms)
Response<Long>	MultiNodePipelineBase.ftDictDelBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	Pipeline.ftDictDelBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	TransactionBase.ftDictDelBySampleKey(String indexName, String dictionary, String... terms)
Response<Set<String>>	MultiNodePipelineBase.ftDictDump(String dictionary)
Response<Set<String>>	Pipeline.ftDictDump(String dictionary)
Response<Set<String>>	TransactionBase.ftDictDump(String dictionary)
Response<Set<String>>	MultiNodePipelineBase.ftDictDumpBySampleKey(String indexName, String dictionary)
Response<Set<String>>	Pipeline.ftDictDumpBySampleKey(String indexName, String dictionary)
Response<Set<String>>	TransactionBase.ftDictDumpBySampleKey(String indexName, String dictionary)
Response<String>	MultiNodePipelineBase.ftDropIndex(String indexName)	Deprecated.
Response<String>	Pipeline.ftDropIndex(String indexName)	Deprecated.
Response<String>	TransactionBase.ftDropIndex(String indexName)	Deprecated.
Response<String>	MultiNodePipelineBase.ftDropIndexDD(String indexName)	Deprecated.
Response<String>	Pipeline.ftDropIndexDD(String indexName)	Deprecated.
Response<String>	TransactionBase.ftDropIndexDD(String indexName)	Deprecated.
Response<String>	MultiNodePipelineBase.ftExplain(String indexName, Query query)
Response<String>	Pipeline.ftExplain(String indexName, Query query)
Response<String>	TransactionBase.ftExplain(String indexName, Query query)
Response<List<String>>	MultiNodePipelineBase.ftExplainCLI(String indexName, Query query)
Response<List<String>>	Pipeline.ftExplainCLI(String indexName, Query query)
Response<List<String>>	TransactionBase.ftExplainCLI(String indexName, Query query)
Response<Map<String,Object>>	MultiNodePipelineBase.ftInfo(String indexName)
Response<Map<String,Object>>	Pipeline.ftInfo(String indexName)
Response<Map<String,Object>>	TransactionBase.ftInfo(String indexName)
Response<SearchResult>	MultiNodePipelineBase.ftSearch(byte[] indexName, Query query)
Response<SearchResult>	MultiNodePipelineBase.ftSearch(String indexName, String query)
Response<SearchResult>	MultiNodePipelineBase.ftSearch(String indexName, String query, FTSearchParams searchParams)
Response<SearchResult>	MultiNodePipelineBase.ftSearch(String indexName, Query query)
Response<SearchResult>	Pipeline.ftSearch(byte[] indexName, Query query)
Response<SearchResult>	Pipeline.ftSearch(String indexName, String query)
Response<SearchResult>	Pipeline.ftSearch(String indexName, String query, FTSearchParams searchParams)
Response<SearchResult>	Pipeline.ftSearch(String indexName, Query query)
Response<SearchResult>	TransactionBase.ftSearch(byte[] indexName, Query query)
Response<SearchResult>	TransactionBase.ftSearch(String indexName, String query)
Response<SearchResult>	TransactionBase.ftSearch(String indexName, String query, FTSearchParams searchParams)
Response<SearchResult>	TransactionBase.ftSearch(String indexName, Query query)
Response<Map<String,Map<String,Double>>>	MultiNodePipelineBase.ftSpellCheck(String index, String query)
Response<Map<String,Map<String,Double>>>	MultiNodePipelineBase.ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams)
Response<Map<String,Map<String,Double>>>	Pipeline.ftSpellCheck(String index, String query)
Response<Map<String,Map<String,Double>>>	Pipeline.ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams)
Response<Map<String,Map<String,Double>>>	TransactionBase.ftSpellCheck(String index, String query)
Response<Map<String,Map<String,Double>>>	TransactionBase.ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams)
Response<Long>	MultiNodePipelineBase.ftSugAdd(String key, String string, double score)
Response<Long>	Pipeline.ftSugAdd(String key, String string, double score)
Response<Long>	TransactionBase.ftSugAdd(String key, String string, double score)
Response<Long>	MultiNodePipelineBase.ftSugAddIncr(String key, String string, double score)
Response<Long>	Pipeline.ftSugAddIncr(String key, String string, double score)
Response<Long>	TransactionBase.ftSugAddIncr(String key, String string, double score)
Response<Boolean>	MultiNodePipelineBase.ftSugDel(String key, String string)
Response<Boolean>	Pipeline.ftSugDel(String key, String string)
Response<Boolean>	TransactionBase.ftSugDel(String key, String string)
Response<List<String>>	MultiNodePipelineBase.ftSugGet(String key, String prefix)
Response<List<String>>	MultiNodePipelineBase.ftSugGet(String key, String prefix, boolean fuzzy, int max)
Response<List<String>>	Pipeline.ftSugGet(String key, String prefix)
Response<List<String>>	Pipeline.ftSugGet(String key, String prefix, boolean fuzzy, int max)
Response<List<String>>	TransactionBase.ftSugGet(String key, String prefix)
Response<List<String>>	TransactionBase.ftSugGet(String key, String prefix, boolean fuzzy, int max)
Response<List<Tuple>>	MultiNodePipelineBase.ftSugGetWithScores(String key, String prefix)
Response<List<Tuple>>	MultiNodePipelineBase.ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max)
Response<List<Tuple>>	Pipeline.ftSugGetWithScores(String key, String prefix)
Response<List<Tuple>>	Pipeline.ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max)
Response<List<Tuple>>	TransactionBase.ftSugGetWithScores(String key, String prefix)
Response<List<Tuple>>	TransactionBase.ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max)
Response<Long>	MultiNodePipelineBase.ftSugLen(String key)
Response<Long>	Pipeline.ftSugLen(String key)
Response<Long>	TransactionBase.ftSugLen(String key)
Response<Map<String,List<String>>>	MultiNodePipelineBase.ftSynDump(String indexName)
Response<Map<String,List<String>>>	Pipeline.ftSynDump(String indexName)
Response<Map<String,List<String>>>	TransactionBase.ftSynDump(String indexName)
Response<String>	MultiNodePipelineBase.ftSynUpdate(String indexName, String synonymGroupId, String... terms)
Response<String>	Pipeline.ftSynUpdate(String indexName, String synonymGroupId, String... terms)
Response<String>	TransactionBase.ftSynUpdate(String indexName, String synonymGroupId, String... terms)
Response<Set<String>>	MultiNodePipelineBase.ftTagVals(String indexName, String fieldName)
Response<Set<String>>	Pipeline.ftTagVals(String indexName, String fieldName)
Response<Set<String>>	TransactionBase.ftTagVals(String indexName, String fieldName)
Response<String>	MultiNodePipelineBase.functionDelete(byte[] libraryName)
Response<String>	MultiNodePipelineBase.functionDelete(String libraryName)
Response<String>	Pipeline.functionDelete(byte[] libraryName)
Response<String>	Pipeline.functionDelete(String libraryName)
Response<String>	TransactionBase.functionDelete(byte[] libraryName)
Response<String>	TransactionBase.functionDelete(String libraryName)
Response<byte[]>	MultiNodePipelineBase.functionDump()
Response<byte[]>	Pipeline.functionDump()
Response<byte[]>	TransactionBase.functionDump()
Response<String>	MultiNodePipelineBase.functionFlush()
Response<String>	MultiNodePipelineBase.functionFlush(FlushMode mode)
Response<String>	Pipeline.functionFlush()
Response<String>	Pipeline.functionFlush(FlushMode mode)
Response<String>	TransactionBase.functionFlush()
Response<String>	TransactionBase.functionFlush(FlushMode mode)
Response<String>	MultiNodePipelineBase.functionKill()
Response<String>	Pipeline.functionKill()
Response<String>	TransactionBase.functionKill()
Response<List<LibraryInfo>>	MultiNodePipelineBase.functionList()
Response<List<Object>>	MultiNodePipelineBase.functionList(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	MultiNodePipelineBase.functionList(String libraryNamePattern)
Response<List<LibraryInfo>>	Pipeline.functionList()
Response<List<Object>>	Pipeline.functionList(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	Pipeline.functionList(String libraryNamePattern)
Response<List<LibraryInfo>>	TransactionBase.functionList()
Response<List<Object>>	TransactionBase.functionList(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	TransactionBase.functionList(String libraryNamePattern)
Response<List<Object>>	MultiNodePipelineBase.functionListBinary()
Response<List<Object>>	Pipeline.functionListBinary()
Response<List<Object>>	TransactionBase.functionListBinary()
Response<List<LibraryInfo>>	MultiNodePipelineBase.functionListWithCode()
Response<List<Object>>	MultiNodePipelineBase.functionListWithCode(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	MultiNodePipelineBase.functionListWithCode(String libraryNamePattern)
Response<List<LibraryInfo>>	Pipeline.functionListWithCode()
Response<List<Object>>	Pipeline.functionListWithCode(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	Pipeline.functionListWithCode(String libraryNamePattern)
Response<List<LibraryInfo>>	TransactionBase.functionListWithCode()
Response<List<Object>>	TransactionBase.functionListWithCode(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	TransactionBase.functionListWithCode(String libraryNamePattern)
Response<List<Object>>	MultiNodePipelineBase.functionListWithCodeBinary()
Response<List<Object>>	Pipeline.functionListWithCodeBinary()
Response<List<Object>>	TransactionBase.functionListWithCodeBinary()
Response<String>	MultiNodePipelineBase.functionLoad(byte[] functionCode)
Response<String>	MultiNodePipelineBase.functionLoad(String functionCode)
Response<String>	Pipeline.functionLoad(byte[] functionCode)
Response<String>	Pipeline.functionLoad(String functionCode)
Response<String>	TransactionBase.functionLoad(byte[] functionCode)
Response<String>	TransactionBase.functionLoad(String functionCode)
Response<String>	MultiNodePipelineBase.functionLoadReplace(byte[] functionCode)
Response<String>	MultiNodePipelineBase.functionLoadReplace(String functionCode)
Response<String>	Pipeline.functionLoadReplace(byte[] functionCode)
Response<String>	Pipeline.functionLoadReplace(String functionCode)
Response<String>	TransactionBase.functionLoadReplace(byte[] functionCode)
Response<String>	TransactionBase.functionLoadReplace(String functionCode)
Response<String>	MultiNodePipelineBase.functionRestore(byte[] serializedValue)
Response<String>	MultiNodePipelineBase.functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<String>	Pipeline.functionRestore(byte[] serializedValue)
Response<String>	Pipeline.functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<String>	TransactionBase.functionRestore(byte[] serializedValue)
Response<String>	TransactionBase.functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<FunctionStats>	MultiNodePipelineBase.functionStats()
Response<FunctionStats>	Pipeline.functionStats()
Response<FunctionStats>	TransactionBase.functionStats()
Response<Object>	MultiNodePipelineBase.functionStatsBinary()
Response<Object>	Pipeline.functionStatsBinary()
Response<Object>	TransactionBase.functionStatsBinary()
protected final Response<?>	Queable.generateResponse(Object data)	Deprecated.
Response<Long>	MultiNodePipelineBase.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	MultiNodePipelineBase.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	MultiNodePipelineBase.geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	MultiNodePipelineBase.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	MultiNodePipelineBase.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	MultiNodePipelineBase.geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	Pipeline.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	Pipeline.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	Pipeline.geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	Pipeline.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	Pipeline.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	Pipeline.geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	TransactionBase.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	TransactionBase.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	TransactionBase.geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	TransactionBase.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	TransactionBase.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	TransactionBase.geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Double>	MultiNodePipelineBase.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	MultiNodePipelineBase.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	MultiNodePipelineBase.geodist(String key, String member1, String member2)
Response<Double>	MultiNodePipelineBase.geodist(String key, String member1, String member2, GeoUnit unit)
Response<Double>	Pipeline.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	Pipeline.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	Pipeline.geodist(String key, String member1, String member2)
Response<Double>	Pipeline.geodist(String key, String member1, String member2, GeoUnit unit)
Response<Double>	TransactionBase.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	TransactionBase.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	TransactionBase.geodist(String key, String member1, String member2)
Response<Double>	TransactionBase.geodist(String key, String member1, String member2, GeoUnit unit)
Response<List<byte[]>>	MultiNodePipelineBase.geohash(byte[] key, byte[]... members)
Response<List<String>>	MultiNodePipelineBase.geohash(String key, String... members)
Response<List<byte[]>>	Pipeline.geohash(byte[] key, byte[]... members)
Response<List<String>>	Pipeline.geohash(String key, String... members)
Response<List<byte[]>>	TransactionBase.geohash(byte[] key, byte[]... members)
Response<List<String>>	TransactionBase.geohash(String key, String... members)
Response<List<GeoCoordinate>>	MultiNodePipelineBase.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	MultiNodePipelineBase.geopos(String key, String... members)
Response<List<GeoCoordinate>>	Pipeline.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	Pipeline.geopos(String key, String... members)
Response<List<GeoCoordinate>>	TransactionBase.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	TransactionBase.geopos(String key, String... members)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiNodePipelineBase.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiNodePipelineBase.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	Pipeline.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	Pipeline.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	TransactionBase.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	TransactionBase.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	MultiNodePipelineBase.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	MultiNodePipelineBase.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	Pipeline.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	Pipeline.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	TransactionBase.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	TransactionBase.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(byte[] key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(String key, String member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	MultiNodePipelineBase.geosearch(String key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(byte[] key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(String key, String member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	Pipeline.geosearch(String key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(byte[] key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(String key, String member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	TransactionBase.geosearch(String key, GeoSearchParam params)
Response<Long>	MultiNodePipelineBase.geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	MultiNodePipelineBase.geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	MultiNodePipelineBase.geosearchStore(String dest, String src, GeoSearchParam params)
Response<Long>	Pipeline.geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	Pipeline.geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	Pipeline.geosearchStore(String dest, String src, GeoSearchParam params)
Response<Long>	TransactionBase.geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	TransactionBase.geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	TransactionBase.geosearchStore(String dest, String src, GeoSearchParam params)
Response<Long>	MultiNodePipelineBase.geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	MultiNodePipelineBase.geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
Response<Long>	Pipeline.geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	Pipeline.geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
Response<Long>	TransactionBase.geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	TransactionBase.geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
Response<byte[]>	MultiNodePipelineBase.get(byte[] key)
Response<String>	MultiNodePipelineBase.get(String key)
Response<byte[]>	Pipeline.get(byte[] key)
Response<String>	Pipeline.get(String key)
Response<byte[]>	TransactionBase.get(byte[] key)
Response<String>	TransactionBase.get(String key)
Response<Boolean>	MultiNodePipelineBase.getbit(byte[] key, long offset)
Response<Boolean>	MultiNodePipelineBase.getbit(String key, long offset)
Response<Boolean>	Pipeline.getbit(byte[] key, long offset)
Response<Boolean>	Pipeline.getbit(String key, long offset)
Response<Boolean>	TransactionBase.getbit(byte[] key, long offset)
Response<Boolean>	TransactionBase.getbit(String key, long offset)
Response<byte[]>	MultiNodePipelineBase.getDel(byte[] key)
Response<String>	MultiNodePipelineBase.getDel(String key)
Response<byte[]>	Pipeline.getDel(byte[] key)
Response<String>	Pipeline.getDel(String key)
Response<byte[]>	TransactionBase.getDel(byte[] key)
Response<String>	TransactionBase.getDel(String key)
Response<byte[]>	MultiNodePipelineBase.getEx(byte[] key, GetExParams params)
Response<String>	MultiNodePipelineBase.getEx(String key, GetExParams params)
Response<byte[]>	Pipeline.getEx(byte[] key, GetExParams params)
Response<String>	Pipeline.getEx(String key, GetExParams params)
Response<byte[]>	TransactionBase.getEx(byte[] key, GetExParams params)
Response<String>	TransactionBase.getEx(String key, GetExParams params)
Response<byte[]>	MultiNodePipelineBase.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	MultiNodePipelineBase.getrange(String key, long startOffset, long endOffset)
Response<byte[]>	Pipeline.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	Pipeline.getrange(String key, long startOffset, long endOffset)
Response<byte[]>	TransactionBase.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	TransactionBase.getrange(String key, long startOffset, long endOffset)
Response<byte[]>	MultiNodePipelineBase.getSet(byte[] key, byte[] value)
Response<String>	MultiNodePipelineBase.getSet(String key, String value)
Response<byte[]>	Pipeline.getSet(byte[] key, byte[] value)
Response<String>	Pipeline.getSet(String key, String value)
Response<byte[]>	TransactionBase.getSet(byte[] key, byte[] value)
Response<String>	TransactionBase.getSet(String key, String value)
Response<String>	MultiNodePipelineBase.graphDelete(String name)
Response<String>	Pipeline.graphDelete(String name)
Response<String>	TransactionBase.graphDelete(String name)
Response<List<String>>	MultiNodePipelineBase.graphProfile(String graphName, String query)
Response<List<String>>	Pipeline.graphProfile(String graphName, String query)
Response<List<String>>	TransactionBase.graphProfile(String graphName, String query)
Response<ResultSet>	MultiNodePipelineBase.graphQuery(String name, String query)
Response<ResultSet>	MultiNodePipelineBase.graphQuery(String name, String query, long timeout)
Response<ResultSet>	MultiNodePipelineBase.graphQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	MultiNodePipelineBase.graphQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	Pipeline.graphQuery(String name, String query)
Response<ResultSet>	Pipeline.graphQuery(String name, String query, long timeout)
Response<ResultSet>	Pipeline.graphQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	Pipeline.graphQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	TransactionBase.graphQuery(String name, String query)
Response<ResultSet>	TransactionBase.graphQuery(String name, String query, long timeout)
Response<ResultSet>	TransactionBase.graphQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	TransactionBase.graphQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	MultiNodePipelineBase.graphReadonlyQuery(String name, String query)
Response<ResultSet>	MultiNodePipelineBase.graphReadonlyQuery(String name, String query, long timeout)
Response<ResultSet>	MultiNodePipelineBase.graphReadonlyQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	MultiNodePipelineBase.graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	Pipeline.graphReadonlyQuery(String name, String query)
Response<ResultSet>	Pipeline.graphReadonlyQuery(String name, String query, long timeout)
Response<ResultSet>	Pipeline.graphReadonlyQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	Pipeline.graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	TransactionBase.graphReadonlyQuery(String name, String query)
Response<ResultSet>	TransactionBase.graphReadonlyQuery(String name, String query, long timeout)
Response<ResultSet>	TransactionBase.graphReadonlyQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	TransactionBase.graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)
Response<Long>	MultiNodePipelineBase.hdel(byte[] key, byte[]... field)
Response<Long>	MultiNodePipelineBase.hdel(String key, String... field)
Response<Long>	Pipeline.hdel(byte[] key, byte[]... field)
Response<Long>	Pipeline.hdel(String key, String... field)
Response<Long>	TransactionBase.hdel(byte[] key, byte[]... field)
Response<Long>	TransactionBase.hdel(String key, String... field)
Response<Boolean>	MultiNodePipelineBase.hexists(byte[] key, byte[] field)
Response<Boolean>	MultiNodePipelineBase.hexists(String key, String field)
Response<Boolean>	Pipeline.hexists(byte[] key, byte[] field)
Response<Boolean>	Pipeline.hexists(String key, String field)
Response<Boolean>	TransactionBase.hexists(byte[] key, byte[] field)
Response<Boolean>	TransactionBase.hexists(String key, String field)
Response<byte[]>	MultiNodePipelineBase.hget(byte[] key, byte[] field)
Response<String>	MultiNodePipelineBase.hget(String key, String field)
Response<byte[]>	Pipeline.hget(byte[] key, byte[] field)
Response<String>	Pipeline.hget(String key, String field)
Response<byte[]>	TransactionBase.hget(byte[] key, byte[] field)
Response<String>	TransactionBase.hget(String key, String field)
Response<Map<byte[],byte[]>>	MultiNodePipelineBase.hgetAll(byte[] key)
Response<Map<String,String>>	MultiNodePipelineBase.hgetAll(String key)
Response<Map<byte[],byte[]>>	Pipeline.hgetAll(byte[] key)
Response<Map<String,String>>	Pipeline.hgetAll(String key)
Response<Map<byte[],byte[]>>	TransactionBase.hgetAll(byte[] key)
Response<Map<String,String>>	TransactionBase.hgetAll(String key)
Response<Long>	MultiNodePipelineBase.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	MultiNodePipelineBase.hincrBy(String key, String field, long value)
Response<Long>	Pipeline.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	Pipeline.hincrBy(String key, String field, long value)
Response<Long>	TransactionBase.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	TransactionBase.hincrBy(String key, String field, long value)
Response<Double>	MultiNodePipelineBase.hincrByFloat(byte[] key, byte[] field, double value)
Response<Double>	MultiNodePipelineBase.hincrByFloat(String key, String field, double value)
Response<Double>	Pipeline.hincrByFloat(byte[] key, byte[] field, double value)
Response<Double>	Pipeline.hincrByFloat(String key, String field, double value)
Response<Double>	TransactionBase.hincrByFloat(byte[] key, byte[] field, double value)
Response<Double>	TransactionBase.hincrByFloat(String key, String field, double value)
Response<Set<byte[]>>	MultiNodePipelineBase.hkeys(byte[] key)
Response<Set<String>>	MultiNodePipelineBase.hkeys(String key)
Response<Set<byte[]>>	Pipeline.hkeys(byte[] key)
Response<Set<String>>	Pipeline.hkeys(String key)
Response<Set<byte[]>>	TransactionBase.hkeys(byte[] key)
Response<Set<String>>	TransactionBase.hkeys(String key)
Response<Long>	MultiNodePipelineBase.hlen(byte[] key)
Response<Long>	MultiNodePipelineBase.hlen(String key)
Response<Long>	Pipeline.hlen(byte[] key)
Response<Long>	Pipeline.hlen(String key)
Response<Long>	TransactionBase.hlen(byte[] key)
Response<Long>	TransactionBase.hlen(String key)
Response<List<byte[]>>	MultiNodePipelineBase.hmget(byte[] key, byte[]... fields)
Response<List<String>>	MultiNodePipelineBase.hmget(String key, String... fields)
Response<List<byte[]>>	Pipeline.hmget(byte[] key, byte[]... fields)
Response<List<String>>	Pipeline.hmget(String key, String... fields)
Response<List<byte[]>>	TransactionBase.hmget(byte[] key, byte[]... fields)
Response<List<String>>	TransactionBase.hmget(String key, String... fields)
Response<String>	MultiNodePipelineBase.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	MultiNodePipelineBase.hmset(String key, Map<String,String> hash)
Response<String>	Pipeline.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	Pipeline.hmset(String key, Map<String,String> hash)
Response<String>	TransactionBase.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	TransactionBase.hmset(String key, Map<String,String> hash)
Response<byte[]>	MultiNodePipelineBase.hrandfield(byte[] key)
Response<List<byte[]>>	MultiNodePipelineBase.hrandfield(byte[] key, long count)
Response<String>	MultiNodePipelineBase.hrandfield(String key)
Response<List<String>>	MultiNodePipelineBase.hrandfield(String key, long count)
Response<byte[]>	Pipeline.hrandfield(byte[] key)
Response<List<byte[]>>	Pipeline.hrandfield(byte[] key, long count)
Response<String>	Pipeline.hrandfield(String key)
Response<List<String>>	Pipeline.hrandfield(String key, long count)
Response<byte[]>	TransactionBase.hrandfield(byte[] key)
Response<List<byte[]>>	TransactionBase.hrandfield(byte[] key, long count)
Response<String>	TransactionBase.hrandfield(String key)
Response<List<String>>	TransactionBase.hrandfield(String key, long count)
Response<Map<byte[],byte[]>>	MultiNodePipelineBase.hrandfieldWithValues(byte[] key, long count)
Response<Map<String,String>>	MultiNodePipelineBase.hrandfieldWithValues(String key, long count)
Response<Map<byte[],byte[]>>	Pipeline.hrandfieldWithValues(byte[] key, long count)
Response<Map<String,String>>	Pipeline.hrandfieldWithValues(String key, long count)
Response<Map<byte[],byte[]>>	TransactionBase.hrandfieldWithValues(byte[] key, long count)
Response<Map<String,String>>	TransactionBase.hrandfieldWithValues(String key, long count)
Response<ScanResult<Map.Entry<byte[],byte[]>>>	MultiNodePipelineBase.hscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Map.Entry<String,String>>>	MultiNodePipelineBase.hscan(String key, String cursor, ScanParams params)
Response<ScanResult<Map.Entry<byte[],byte[]>>>	Pipeline.hscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Map.Entry<String,String>>>	Pipeline.hscan(String key, String cursor, ScanParams params)
Response<ScanResult<Map.Entry<byte[],byte[]>>>	TransactionBase.hscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Map.Entry<String,String>>>	TransactionBase.hscan(String key, String cursor, ScanParams params)
Response<Long>	MultiNodePipelineBase.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	MultiNodePipelineBase.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	MultiNodePipelineBase.hset(String key, String field, String value)
Response<Long>	MultiNodePipelineBase.hset(String key, Map<String,String> hash)
Response<Long>	Pipeline.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	Pipeline.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	Pipeline.hset(String key, String field, String value)
Response<Long>	Pipeline.hset(String key, Map<String,String> hash)
Response<Long>	TransactionBase.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	TransactionBase.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	TransactionBase.hset(String key, String field, String value)
Response<Long>	TransactionBase.hset(String key, Map<String,String> hash)
Response<Long>	MultiNodePipelineBase.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	MultiNodePipelineBase.hsetnx(String key, String field, String value)
Response<Long>	Pipeline.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	Pipeline.hsetnx(String key, String field, String value)
Response<Long>	TransactionBase.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	TransactionBase.hsetnx(String key, String field, String value)
Response<Long>	MultiNodePipelineBase.hstrlen(byte[] key, byte[] field)
Response<Long>	MultiNodePipelineBase.hstrlen(String key, String field)
Response<Long>	Pipeline.hstrlen(byte[] key, byte[] field)
Response<Long>	Pipeline.hstrlen(String key, String field)
Response<Long>	TransactionBase.hstrlen(byte[] key, byte[] field)
Response<Long>	TransactionBase.hstrlen(String key, String field)
Response<List<byte[]>>	MultiNodePipelineBase.hvals(byte[] key)
Response<List<String>>	MultiNodePipelineBase.hvals(String key)
Response<List<byte[]>>	Pipeline.hvals(byte[] key)
Response<List<String>>	Pipeline.hvals(String key)
Response<List<byte[]>>	TransactionBase.hvals(byte[] key)
Response<List<String>>	TransactionBase.hvals(String key)
Response<Long>	MultiNodePipelineBase.incr(byte[] key)
Response<Long>	MultiNodePipelineBase.incr(String key)
Response<Long>	Pipeline.incr(byte[] key)
Response<Long>	Pipeline.incr(String key)
Response<Long>	TransactionBase.incr(byte[] key)
Response<Long>	TransactionBase.incr(String key)
Response<Long>	MultiNodePipelineBase.incrBy(byte[] key, long increment)
Response<Long>	MultiNodePipelineBase.incrBy(String key, long increment)
Response<Long>	Pipeline.incrBy(byte[] key, long increment)
Response<Long>	Pipeline.incrBy(String key, long increment)
Response<Long>	TransactionBase.incrBy(byte[] key, long increment)
Response<Long>	TransactionBase.incrBy(String key, long increment)
Response<Double>	MultiNodePipelineBase.incrByFloat(byte[] key, double increment)
Response<Double>	MultiNodePipelineBase.incrByFloat(String key, double increment)
Response<Double>	Pipeline.incrByFloat(byte[] key, double increment)
Response<Double>	Pipeline.incrByFloat(String key, double increment)
Response<Double>	TransactionBase.incrByFloat(byte[] key, double increment)
Response<Double>	TransactionBase.incrByFloat(String key, double increment)
Response<List<Long>>	MultiNodePipelineBase.jsonArrAppend(String key, Path2 path, Object... objects)
Response<Long>	MultiNodePipelineBase.jsonArrAppend(String key, Path path, Object... objects)
Response<List<Long>>	Pipeline.jsonArrAppend(String key, Path2 path, Object... objects)
Response<Long>	Pipeline.jsonArrAppend(String key, Path path, Object... objects)
Response<List<Long>>	TransactionBase.jsonArrAppend(String key, Path2 path, Object... objects)
Response<Long>	TransactionBase.jsonArrAppend(String key, Path path, Object... objects)
Response<List<Long>>	MultiNodePipelineBase.jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
Response<List<Long>>	Pipeline.jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
Response<List<Long>>	TransactionBase.jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
Response<List<Long>>	MultiNodePipelineBase.jsonArrIndex(String key, Path2 path, Object scalar)
Response<Long>	MultiNodePipelineBase.jsonArrIndex(String key, Path path, Object scalar)
Response<List<Long>>	Pipeline.jsonArrIndex(String key, Path2 path, Object scalar)
Response<Long>	Pipeline.jsonArrIndex(String key, Path path, Object scalar)
Response<List<Long>>	TransactionBase.jsonArrIndex(String key, Path2 path, Object scalar)
Response<Long>	TransactionBase.jsonArrIndex(String key, Path path, Object scalar)
Response<List<Long>>	MultiNodePipelineBase.jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
Response<List<Long>>	Pipeline.jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
Response<List<Long>>	TransactionBase.jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
Response<List<Long>>	MultiNodePipelineBase.jsonArrInsert(String key, Path2 path, int index, Object... objects)
Response<Long>	MultiNodePipelineBase.jsonArrInsert(String key, Path path, int index, Object... pojos)
Response<List<Long>>	Pipeline.jsonArrInsert(String key, Path2 path, int index, Object... objects)
Response<Long>	Pipeline.jsonArrInsert(String key, Path path, int index, Object... pojos)
Response<List<Long>>	TransactionBase.jsonArrInsert(String key, Path2 path, int index, Object... objects)
Response<Long>	TransactionBase.jsonArrInsert(String key, Path path, int index, Object... pojos)
Response<List<Long>>	MultiNodePipelineBase.jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
Response<List<Long>>	Pipeline.jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
Response<List<Long>>	TransactionBase.jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
Response<Long>	MultiNodePipelineBase.jsonArrLen(String key)
Response<Long>	MultiNodePipelineBase.jsonArrLen(String key, Path path)
Response<List<Long>>	MultiNodePipelineBase.jsonArrLen(String key, Path2 path)
Response<Long>	Pipeline.jsonArrLen(String key)
Response<Long>	Pipeline.jsonArrLen(String key, Path path)
Response<List<Long>>	Pipeline.jsonArrLen(String key, Path2 path)
Response<Long>	TransactionBase.jsonArrLen(String key)
Response<Long>	TransactionBase.jsonArrLen(String key, Path path)
Response<List<Long>>	TransactionBase.jsonArrLen(String key, Path2 path)
Response<Object>	MultiNodePipelineBase.jsonArrPop(String key)
<T> Response<T>	MultiNodePipelineBase.jsonArrPop(String key, Class<T> clazz)
<T> Response<T>	MultiNodePipelineBase.jsonArrPop(String key, Class<T> clazz, Path path)
<T> Response<T>	MultiNodePipelineBase.jsonArrPop(String key, Class<T> clazz, Path path, int index)
Response<Object>	MultiNodePipelineBase.jsonArrPop(String key, Path path)
Response<List<Object>>	MultiNodePipelineBase.jsonArrPop(String key, Path2 path)
Response<List<Object>>	MultiNodePipelineBase.jsonArrPop(String key, Path2 path, int index)
Response<Object>	MultiNodePipelineBase.jsonArrPop(String key, Path path, int index)
Response<Object>	Pipeline.jsonArrPop(String key)
<T> Response<T>	Pipeline.jsonArrPop(String key, Class<T> clazz)
<T> Response<T>	Pipeline.jsonArrPop(String key, Class<T> clazz, Path path)
<T> Response<T>	Pipeline.jsonArrPop(String key, Class<T> clazz, Path path, int index)
Response<Object>	Pipeline.jsonArrPop(String key, Path path)
Response<List<Object>>	Pipeline.jsonArrPop(String key, Path2 path)
Response<List<Object>>	Pipeline.jsonArrPop(String key, Path2 path, int index)
Response<Object>	Pipeline.jsonArrPop(String key, Path path, int index)
Response<Object>	TransactionBase.jsonArrPop(String key)
<T> Response<T>	TransactionBase.jsonArrPop(String key, Class<T> clazz)
<T> Response<T>	TransactionBase.jsonArrPop(String key, Class<T> clazz, Path path)
<T> Response<T>	TransactionBase.jsonArrPop(String key, Class<T> clazz, Path path, int index)
Response<Object>	TransactionBase.jsonArrPop(String key, Path path)
Response<List<Object>>	TransactionBase.jsonArrPop(String key, Path2 path)
Response<List<Object>>	TransactionBase.jsonArrPop(String key, Path2 path, int index)
Response<Object>	TransactionBase.jsonArrPop(String key, Path path, int index)
Response<List<Long>>	MultiNodePipelineBase.jsonArrTrim(String key, Path2 path, int start, int stop)
Response<Long>	MultiNodePipelineBase.jsonArrTrim(String key, Path path, int start, int stop)
Response<List<Long>>	Pipeline.jsonArrTrim(String key, Path2 path, int start, int stop)
Response<Long>	Pipeline.jsonArrTrim(String key, Path path, int start, int stop)
Response<List<Long>>	TransactionBase.jsonArrTrim(String key, Path2 path, int start, int stop)
Response<Long>	TransactionBase.jsonArrTrim(String key, Path path, int start, int stop)
Response<Long>	MultiNodePipelineBase.jsonClear(String key)
Response<Long>	MultiNodePipelineBase.jsonClear(String key, Path path)
Response<Long>	MultiNodePipelineBase.jsonClear(String key, Path2 path)
Response<Long>	Pipeline.jsonClear(String key)
Response<Long>	Pipeline.jsonClear(String key, Path path)
Response<Long>	Pipeline.jsonClear(String key, Path2 path)
Response<Long>	TransactionBase.jsonClear(String key)
Response<Long>	TransactionBase.jsonClear(String key, Path path)
Response<Long>	TransactionBase.jsonClear(String key, Path2 path)
Response<Long>	MultiNodePipelineBase.jsonDel(String key)
Response<Long>	MultiNodePipelineBase.jsonDel(String key, Path path)
Response<Long>	MultiNodePipelineBase.jsonDel(String key, Path2 path)
Response<Long>	Pipeline.jsonDel(String key)
Response<Long>	Pipeline.jsonDel(String key, Path path)
Response<Long>	Pipeline.jsonDel(String key, Path2 path)
Response<Long>	TransactionBase.jsonDel(String key)
Response<Long>	TransactionBase.jsonDel(String key, Path path)
Response<Long>	TransactionBase.jsonDel(String key, Path2 path)
Response<Object>	MultiNodePipelineBase.jsonGet(String key)
<T> Response<T>	MultiNodePipelineBase.jsonGet(String key, Class<T> clazz)
<T> Response<T>	MultiNodePipelineBase.jsonGet(String key, Class<T> clazz, Path... paths)
Response<Object>	MultiNodePipelineBase.jsonGet(String key, Path... paths)
Response<Object>	MultiNodePipelineBase.jsonGet(String key, Path2... paths)
Response<Object>	Pipeline.jsonGet(String key)
<T> Response<T>	Pipeline.jsonGet(String key, Class<T> clazz)
<T> Response<T>	Pipeline.jsonGet(String key, Class<T> clazz, Path... paths)
Response<Object>	Pipeline.jsonGet(String key, Path... paths)
Response<Object>	Pipeline.jsonGet(String key, Path2... paths)
Response<Object>	TransactionBase.jsonGet(String key)
<T> Response<T>	TransactionBase.jsonGet(String key, Class<T> clazz)
<T> Response<T>	TransactionBase.jsonGet(String key, Class<T> clazz, Path... paths)
Response<Object>	TransactionBase.jsonGet(String key, Path... paths)
Response<Object>	TransactionBase.jsonGet(String key, Path2... paths)
Response<List<org.json.JSONArray>>	MultiNodePipelineBase.jsonMGet(Path2 path, String... keys)
<T> Response<List<T>>	MultiNodePipelineBase.jsonMGet(Path path, Class<T> clazz, String... keys)
Response<List<org.json.JSONArray>>	Pipeline.jsonMGet(Path2 path, String... keys)
<T> Response<List<T>>	Pipeline.jsonMGet(Path path, Class<T> clazz, String... keys)
Response<List<org.json.JSONArray>>	TransactionBase.jsonMGet(Path2 path, String... keys)
<T> Response<List<T>>	TransactionBase.jsonMGet(Path path, Class<T> clazz, String... keys)
Response<org.json.JSONArray>	MultiNodePipelineBase.jsonNumIncrBy(String key, Path2 path, double value)
Response<Double>	MultiNodePipelineBase.jsonNumIncrBy(String key, Path path, double value)
Response<org.json.JSONArray>	Pipeline.jsonNumIncrBy(String key, Path2 path, double value)
Response<Double>	Pipeline.jsonNumIncrBy(String key, Path path, double value)
Response<org.json.JSONArray>	TransactionBase.jsonNumIncrBy(String key, Path2 path, double value)
Response<Double>	TransactionBase.jsonNumIncrBy(String key, Path path, double value)
Response<String>	MultiNodePipelineBase.jsonSet(String key, Path2 path, Object object)
Response<String>	MultiNodePipelineBase.jsonSet(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	MultiNodePipelineBase.jsonSet(String key, Path path, Object object)
Response<String>	MultiNodePipelineBase.jsonSet(String key, Path path, Object object, JsonSetParams params)
Response<String>	Pipeline.jsonSet(String key, Path2 path, Object object)
Response<String>	Pipeline.jsonSet(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	Pipeline.jsonSet(String key, Path path, Object object)
Response<String>	Pipeline.jsonSet(String key, Path path, Object object, JsonSetParams params)
Response<String>	TransactionBase.jsonSet(String key, Path2 path, Object object)
Response<String>	TransactionBase.jsonSet(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	TransactionBase.jsonSet(String key, Path path, Object object)
Response<String>	TransactionBase.jsonSet(String key, Path path, Object object, JsonSetParams params)
Response<String>	MultiNodePipelineBase.jsonSetWithEscape(String key, Path2 path, Object object)
Response<String>	MultiNodePipelineBase.jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	Pipeline.jsonSetWithEscape(String key, Path2 path, Object object)
Response<String>	Pipeline.jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	TransactionBase.jsonSetWithEscape(String key, Path2 path, Object object)
Response<String>	TransactionBase.jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params)
Response<Long>	MultiNodePipelineBase.jsonStrAppend(String key, Object string)
Response<List<Long>>	MultiNodePipelineBase.jsonStrAppend(String key, Path2 path, Object string)
Response<Long>	MultiNodePipelineBase.jsonStrAppend(String key, Path path, Object string)
Response<Long>	Pipeline.jsonStrAppend(String key, Object string)
Response<List<Long>>	Pipeline.jsonStrAppend(String key, Path2 path, Object string)
Response<Long>	Pipeline.jsonStrAppend(String key, Path path, Object string)
Response<Long>	TransactionBase.jsonStrAppend(String key, Object string)
Response<List<Long>>	TransactionBase.jsonStrAppend(String key, Path2 path, Object string)
Response<Long>	TransactionBase.jsonStrAppend(String key, Path path, Object string)
Response<Long>	MultiNodePipelineBase.jsonStrLen(String key)
Response<Long>	MultiNodePipelineBase.jsonStrLen(String key, Path path)
Response<List<Long>>	MultiNodePipelineBase.jsonStrLen(String key, Path2 path)
Response<Long>	Pipeline.jsonStrLen(String key)
Response<Long>	Pipeline.jsonStrLen(String key, Path path)
Response<List<Long>>	Pipeline.jsonStrLen(String key, Path2 path)
Response<Long>	TransactionBase.jsonStrLen(String key)
Response<Long>	TransactionBase.jsonStrLen(String key, Path path)
Response<List<Long>>	TransactionBase.jsonStrLen(String key, Path2 path)
Response<String>	MultiNodePipelineBase.jsonToggle(String key, Path path)
Response<List<Boolean>>	MultiNodePipelineBase.jsonToggle(String key, Path2 path)
Response<String>	Pipeline.jsonToggle(String key, Path path)
Response<List<Boolean>>	Pipeline.jsonToggle(String key, Path2 path)
Response<String>	TransactionBase.jsonToggle(String key, Path path)
Response<List<Boolean>>	TransactionBase.jsonToggle(String key, Path2 path)
Response<Class<?>>	MultiNodePipelineBase.jsonType(String key)
Response<Class<?>>	MultiNodePipelineBase.jsonType(String key, Path path)
Response<List<Class<?>>>	MultiNodePipelineBase.jsonType(String key, Path2 path)
Response<Class<?>>	Pipeline.jsonType(String key)
Response<Class<?>>	Pipeline.jsonType(String key, Path path)
Response<List<Class<?>>>	Pipeline.jsonType(String key, Path2 path)
Response<Class<?>>	TransactionBase.jsonType(String key)
Response<Class<?>>	TransactionBase.jsonType(String key, Path path)
Response<List<Class<?>>>	TransactionBase.jsonType(String key, Path2 path)
Response<Set<byte[]>>	MultiNodePipelineBase.keys(byte[] pattern)
Response<Set<String>>	MultiNodePipelineBase.keys(String pattern)
Response<Set<byte[]>>	Pipeline.keys(byte[] pattern)
Response<Set<String>>	Pipeline.keys(String pattern)
Response<Set<byte[]>>	TransactionBase.keys(byte[] pattern)
Response<Set<String>>	TransactionBase.keys(String pattern)
Response<LCSMatchResult>	MultiNodePipelineBase.lcs(byte[] keyA, byte[] keyB, LCSParams params)
Response<LCSMatchResult>	MultiNodePipelineBase.lcs(String keyA, String keyB, LCSParams params)
Response<LCSMatchResult>	Pipeline.lcs(byte[] keyA, byte[] keyB, LCSParams params)
Response<LCSMatchResult>	Pipeline.lcs(String keyA, String keyB, LCSParams params)
Response<LCSMatchResult>	TransactionBase.lcs(byte[] keyA, byte[] keyB, LCSParams params)
Response<LCSMatchResult>	TransactionBase.lcs(String keyA, String keyB, LCSParams params)
Response<byte[]>	MultiNodePipelineBase.lindex(byte[] key, long index)
Response<String>	MultiNodePipelineBase.lindex(String key, long index)
Response<byte[]>	Pipeline.lindex(byte[] key, long index)
Response<String>	Pipeline.lindex(String key, long index)
Response<byte[]>	TransactionBase.lindex(byte[] key, long index)
Response<String>	TransactionBase.lindex(String key, long index)
Response<Long>	MultiNodePipelineBase.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	MultiNodePipelineBase.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	Pipeline.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	Pipeline.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	TransactionBase.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	TransactionBase.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	MultiNodePipelineBase.llen(byte[] key)
Response<Long>	MultiNodePipelineBase.llen(String key)
Response<Long>	Pipeline.llen(byte[] key)
Response<Long>	Pipeline.llen(String key)
Response<Long>	TransactionBase.llen(byte[] key)
Response<Long>	TransactionBase.llen(String key)
Response<byte[]>	MultiNodePipelineBase.lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to)
Response<String>	MultiNodePipelineBase.lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
Response<byte[]>	Pipeline.lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to)
Response<String>	Pipeline.lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
Response<byte[]>	TransactionBase.lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to)
Response<String>	TransactionBase.lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
Response<KeyValue<byte[],List<byte[]>>>	MultiNodePipelineBase.lmpop(ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	MultiNodePipelineBase.lmpop(ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	MultiNodePipelineBase.lmpop(ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	MultiNodePipelineBase.lmpop(ListDirection direction, String... keys)
Response<KeyValue<byte[],List<byte[]>>>	Pipeline.lmpop(ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	Pipeline.lmpop(ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	Pipeline.lmpop(ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	Pipeline.lmpop(ListDirection direction, String... keys)
Response<KeyValue<byte[],List<byte[]>>>	TransactionBase.lmpop(ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	TransactionBase.lmpop(ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	TransactionBase.lmpop(ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	TransactionBase.lmpop(ListDirection direction, String... keys)
Response<byte[]>	MultiNodePipelineBase.lpop(byte[] key)
Response<List<byte[]>>	MultiNodePipelineBase.lpop(byte[] key, int count)
Response<String>	MultiNodePipelineBase.lpop(String key)
Response<List<String>>	MultiNodePipelineBase.lpop(String key, int count)
Response<byte[]>	Pipeline.lpop(byte[] key)
Response<List<byte[]>>	Pipeline.lpop(byte[] key, int count)
Response<String>	Pipeline.lpop(String key)
Response<List<String>>	Pipeline.lpop(String key, int count)
Response<byte[]>	TransactionBase.lpop(byte[] key)
Response<List<byte[]>>	TransactionBase.lpop(byte[] key, int count)
Response<String>	TransactionBase.lpop(String key)
Response<List<String>>	TransactionBase.lpop(String key, int count)
Response<Long>	MultiNodePipelineBase.lpos(byte[] key, byte[] element)
Response<Long>	MultiNodePipelineBase.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	MultiNodePipelineBase.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	MultiNodePipelineBase.lpos(String key, String element)
Response<Long>	MultiNodePipelineBase.lpos(String key, String element, LPosParams params)
Response<List<Long>>	MultiNodePipelineBase.lpos(String key, String element, LPosParams params, long count)
Response<Long>	Pipeline.lpos(byte[] key, byte[] element)
Response<Long>	Pipeline.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	Pipeline.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	Pipeline.lpos(String key, String element)
Response<Long>	Pipeline.lpos(String key, String element, LPosParams params)
Response<List<Long>>	Pipeline.lpos(String key, String element, LPosParams params, long count)
Response<Long>	TransactionBase.lpos(byte[] key, byte[] element)
Response<Long>	TransactionBase.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	TransactionBase.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	TransactionBase.lpos(String key, String element)
Response<Long>	TransactionBase.lpos(String key, String element, LPosParams params)
Response<List<Long>>	TransactionBase.lpos(String key, String element, LPosParams params, long count)
Response<Long>	MultiNodePipelineBase.lpush(byte[] key, byte[]... args)
Response<Long>	MultiNodePipelineBase.lpush(String key, String... string)
Response<Long>	Pipeline.lpush(byte[] key, byte[]... args)
Response<Long>	Pipeline.lpush(String key, String... string)
Response<Long>	TransactionBase.lpush(byte[] key, byte[]... args)
Response<Long>	TransactionBase.lpush(String key, String... string)
Response<Long>	MultiNodePipelineBase.lpushx(byte[] key, byte[]... args)
Response<Long>	MultiNodePipelineBase.lpushx(String key, String... strings)
Response<Long>	Pipeline.lpushx(byte[] key, byte[]... args)
Response<Long>	Pipeline.lpushx(String key, String... strings)
Response<Long>	TransactionBase.lpushx(byte[] key, byte[]... args)
Response<Long>	TransactionBase.lpushx(String key, String... strings)
Response<List<byte[]>>	MultiNodePipelineBase.lrange(byte[] key, long start, long stop)
Response<List<String>>	MultiNodePipelineBase.lrange(String key, long start, long stop)
Response<List<byte[]>>	Pipeline.lrange(byte[] key, long start, long stop)
Response<List<String>>	Pipeline.lrange(String key, long start, long stop)
Response<List<byte[]>>	TransactionBase.lrange(byte[] key, long start, long stop)
Response<List<String>>	TransactionBase.lrange(String key, long start, long stop)
Response<Long>	MultiNodePipelineBase.lrem(byte[] key, long count, byte[] value)
Response<Long>	MultiNodePipelineBase.lrem(String key, long count, String value)
Response<Long>	Pipeline.lrem(byte[] key, long count, byte[] value)
Response<Long>	Pipeline.lrem(String key, long count, String value)
Response<Long>	TransactionBase.lrem(byte[] key, long count, byte[] value)
Response<Long>	TransactionBase.lrem(String key, long count, String value)
Response<String>	MultiNodePipelineBase.lset(byte[] key, long index, byte[] value)
Response<String>	MultiNodePipelineBase.lset(String key, long index, String value)
Response<String>	Pipeline.lset(byte[] key, long index, byte[] value)
Response<String>	Pipeline.lset(String key, long index, String value)
Response<String>	TransactionBase.lset(byte[] key, long index, byte[] value)
Response<String>	TransactionBase.lset(String key, long index, String value)
Response<String>	MultiNodePipelineBase.ltrim(byte[] key, long start, long stop)
Response<String>	MultiNodePipelineBase.ltrim(String key, long start, long stop)
Response<String>	Pipeline.ltrim(byte[] key, long start, long stop)
Response<String>	Pipeline.ltrim(String key, long start, long stop)
Response<String>	TransactionBase.ltrim(byte[] key, long start, long stop)
Response<String>	TransactionBase.ltrim(String key, long start, long stop)
Response<Long>	MultiNodePipelineBase.memoryUsage(byte[] key)
Response<Long>	MultiNodePipelineBase.memoryUsage(byte[] key, int samples)
Response<Long>	MultiNodePipelineBase.memoryUsage(String key)
Response<Long>	MultiNodePipelineBase.memoryUsage(String key, int samples)
Response<Long>	Pipeline.memoryUsage(byte[] key)
Response<Long>	Pipeline.memoryUsage(byte[] key, int samples)
Response<Long>	Pipeline.memoryUsage(String key)
Response<Long>	Pipeline.memoryUsage(String key, int samples)
Response<Long>	TransactionBase.memoryUsage(byte[] key)
Response<Long>	TransactionBase.memoryUsage(byte[] key, int samples)
Response<Long>	TransactionBase.memoryUsage(String key)
Response<Long>	TransactionBase.memoryUsage(String key, int samples)
Response<List<byte[]>>	MultiNodePipelineBase.mget(byte[]... keys)
Response<List<String>>	MultiNodePipelineBase.mget(String... keys)
Response<List<byte[]>>	Pipeline.mget(byte[]... keys)
Response<List<String>>	Pipeline.mget(String... keys)
Response<List<byte[]>>	TransactionBase.mget(byte[]... keys)
Response<List<String>>	TransactionBase.mget(String... keys)
Response<String>	MultiNodePipelineBase.migrate(String host, int port, byte[] key, int timeout)
Response<String>	MultiNodePipelineBase.migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
Response<String>	MultiNodePipelineBase.migrate(String host, int port, int timeout, MigrateParams params, String... keys)
Response<String>	MultiNodePipelineBase.migrate(String host, int port, String key, int timeout)
Response<String>	Pipeline.migrate(String host, int port, byte[] key, int timeout)
Response<String>	Pipeline.migrate(String host, int port, byte[] key, int destinationDB, int timeout)
Response<String>	Pipeline.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, byte[]... keys)
Response<String>	Pipeline.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, String... keys)
Response<String>	Pipeline.migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
Response<String>	Pipeline.migrate(String host, int port, int timeout, MigrateParams params, String... keys)
Response<String>	Pipeline.migrate(String host, int port, String key, int timeout)
Response<String>	Pipeline.migrate(String host, int port, String key, int destinationDB, int timeout)
Response<String>	TransactionBase.migrate(String host, int port, byte[] key, int timeout)
Response<String>	TransactionBase.migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
Response<String>	TransactionBase.migrate(String host, int port, int timeout, MigrateParams params, String... keys)
Response<String>	TransactionBase.migrate(String host, int port, String key, int timeout)
Response<Long>	Pipeline.move(byte[] key, int dbIndex)
Response<Long>	Pipeline.move(String key, int dbIndex)
Response<String>	MultiNodePipelineBase.mset(byte[]... keysvalues)
Response<String>	MultiNodePipelineBase.mset(String... keysvalues)
Response<String>	Pipeline.mset(byte[]... keysvalues)
Response<String>	Pipeline.mset(String... keysvalues)
Response<String>	TransactionBase.mset(byte[]... keysvalues)
Response<String>	TransactionBase.mset(String... keysvalues)
Response<Long>	MultiNodePipelineBase.msetnx(byte[]... keysvalues)
Response<Long>	MultiNodePipelineBase.msetnx(String... keysvalues)
Response<Long>	Pipeline.msetnx(byte[]... keysvalues)
Response<Long>	Pipeline.msetnx(String... keysvalues)
Response<Long>	TransactionBase.msetnx(byte[]... keysvalues)
Response<Long>	TransactionBase.msetnx(String... keysvalues)
Response<byte[]>	MultiNodePipelineBase.objectEncoding(byte[] key)
Response<String>	MultiNodePipelineBase.objectEncoding(String key)
Response<byte[]>	Pipeline.objectEncoding(byte[] key)
Response<String>	Pipeline.objectEncoding(String key)
Response<byte[]>	TransactionBase.objectEncoding(byte[] key)
Response<String>	TransactionBase.objectEncoding(String key)
Response<Long>	MultiNodePipelineBase.objectFreq(byte[] key)
Response<Long>	MultiNodePipelineBase.objectFreq(String key)
Response<Long>	Pipeline.objectFreq(byte[] key)
Response<Long>	Pipeline.objectFreq(String key)
Response<Long>	TransactionBase.objectFreq(byte[] key)
Response<Long>	TransactionBase.objectFreq(String key)
Response<Long>	MultiNodePipelineBase.objectIdletime(byte[] key)
Response<Long>	MultiNodePipelineBase.objectIdletime(String key)
Response<Long>	Pipeline.objectIdletime(byte[] key)
Response<Long>	Pipeline.objectIdletime(String key)
Response<Long>	TransactionBase.objectIdletime(byte[] key)
Response<Long>	TransactionBase.objectIdletime(String key)
Response<Long>	MultiNodePipelineBase.objectRefcount(byte[] key)
Response<Long>	MultiNodePipelineBase.objectRefcount(String key)
Response<Long>	Pipeline.objectRefcount(byte[] key)
Response<Long>	Pipeline.objectRefcount(String key)
Response<Long>	TransactionBase.objectRefcount(byte[] key)
Response<Long>	TransactionBase.objectRefcount(String key)
Response<Long>	MultiNodePipelineBase.persist(byte[] key)
Response<Long>	MultiNodePipelineBase.persist(String key)
Response<Long>	Pipeline.persist(byte[] key)
Response<Long>	Pipeline.persist(String key)
Response<Long>	TransactionBase.persist(byte[] key)
Response<Long>	TransactionBase.persist(String key)
Response<Long>	MultiNodePipelineBase.pexpire(byte[] key, long milliseconds)
Response<Long>	MultiNodePipelineBase.pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.pexpire(String key, long milliseconds)
Response<Long>	MultiNodePipelineBase.pexpire(String key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	Pipeline.pexpire(byte[] key, long milliseconds)
Response<Long>	Pipeline.pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	Pipeline.pexpire(String key, long milliseconds)
Response<Long>	Pipeline.pexpire(String key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	TransactionBase.pexpire(byte[] key, long milliseconds)
Response<Long>	TransactionBase.pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	TransactionBase.pexpire(String key, long milliseconds)
Response<Long>	TransactionBase.pexpire(String key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	MultiNodePipelineBase.pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	MultiNodePipelineBase.pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	Pipeline.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	Pipeline.pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	Pipeline.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	Pipeline.pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	TransactionBase.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	TransactionBase.pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	TransactionBase.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	TransactionBase.pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	MultiNodePipelineBase.pexpireTime(byte[] key)
Response<Long>	MultiNodePipelineBase.pexpireTime(String key)
Response<Long>	Pipeline.pexpireTime(byte[] key)
Response<Long>	Pipeline.pexpireTime(String key)
Response<Long>	TransactionBase.pexpireTime(byte[] key)
Response<Long>	TransactionBase.pexpireTime(String key)
Response<Long>	MultiNodePipelineBase.pfadd(byte[] key, byte[]... elements)
Response<Long>	MultiNodePipelineBase.pfadd(String key, String... elements)
Response<Long>	Pipeline.pfadd(byte[] key, byte[]... elements)
Response<Long>	Pipeline.pfadd(String key, String... elements)
Response<Long>	TransactionBase.pfadd(byte[] key, byte[]... elements)
Response<Long>	TransactionBase.pfadd(String key, String... elements)
Response<Long>	MultiNodePipelineBase.pfcount(byte[] key)
Response<Long>	MultiNodePipelineBase.pfcount(byte[]... keys)
Response<Long>	MultiNodePipelineBase.pfcount(String key)
Response<Long>	MultiNodePipelineBase.pfcount(String... keys)
Response<Long>	Pipeline.pfcount(byte[] key)
Response<Long>	Pipeline.pfcount(byte[]... keys)
Response<Long>	Pipeline.pfcount(String key)
Response<Long>	Pipeline.pfcount(String... keys)
Response<Long>	TransactionBase.pfcount(byte[] key)
Response<Long>	TransactionBase.pfcount(byte[]... keys)
Response<Long>	TransactionBase.pfcount(String key)
Response<Long>	TransactionBase.pfcount(String... keys)
Response<String>	MultiNodePipelineBase.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	MultiNodePipelineBase.pfmerge(String destkey, String... sourcekeys)
Response<String>	Pipeline.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	Pipeline.pfmerge(String destkey, String... sourcekeys)
Response<String>	TransactionBase.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	TransactionBase.pfmerge(String destkey, String... sourcekeys)
Response<String>	MultiNodePipelineBase.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	MultiNodePipelineBase.psetex(String key, long milliseconds, String value)
Response<String>	Pipeline.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	Pipeline.psetex(String key, long milliseconds, String value)
Response<String>	TransactionBase.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	TransactionBase.psetex(String key, long milliseconds, String value)
Response<Long>	MultiNodePipelineBase.pttl(byte[] key)
Response<Long>	MultiNodePipelineBase.pttl(String key)
Response<Long>	Pipeline.pttl(byte[] key)
Response<Long>	Pipeline.pttl(String key)
Response<Long>	TransactionBase.pttl(byte[] key)
Response<Long>	TransactionBase.pttl(String key)
Response<Long>	MultiNodePipelineBase.publish(byte[] channel, byte[] message)
Response<Long>	MultiNodePipelineBase.publish(String channel, String message)
Response<Long>	Pipeline.publish(byte[] channel, byte[] message)
Response<Long>	Pipeline.publish(String channel, String message)
Response<Long>	TransactionBase.publish(byte[] channel, byte[] message)
Response<Long>	TransactionBase.publish(String channel, String message)
Response<byte[]>	MultiNodePipelineBase.randomBinaryKey()
Response<byte[]>	Pipeline.randomBinaryKey()
Response<byte[]>	TransactionBase.randomBinaryKey()
Response<String>	MultiNodePipelineBase.randomKey()
Response<String>	Pipeline.randomKey()
Response<String>	TransactionBase.randomKey()
Response<String>	MultiNodePipelineBase.rename(byte[] oldkey, byte[] newkey)
Response<String>	MultiNodePipelineBase.rename(String oldKey, String newKey)
Response<String>	Pipeline.rename(byte[] oldkey, byte[] newkey)
Response<String>	Pipeline.rename(String oldkey, String newkey)
Response<String>	TransactionBase.rename(byte[] oldkey, byte[] newkey)
Response<String>	TransactionBase.rename(String oldkey, String newkey)
Response<Long>	MultiNodePipelineBase.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	MultiNodePipelineBase.renamenx(String oldKey, String newKey)
Response<Long>	Pipeline.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	Pipeline.renamenx(String oldkey, String newkey)
Response<Long>	TransactionBase.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	TransactionBase.renamenx(String oldkey, String newkey)
Response<String>	MultiNodePipelineBase.restore(byte[] key, long ttl, byte[] serializedValue)
Response<String>	MultiNodePipelineBase.restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	MultiNodePipelineBase.restore(String key, long ttl, byte[] serializedValue)
Response<String>	MultiNodePipelineBase.restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	Pipeline.restore(byte[] key, long ttl, byte[] serializedValue)
Response<String>	Pipeline.restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	Pipeline.restore(String key, long ttl, byte[] serializedValue)
Response<String>	Pipeline.restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	TransactionBase.restore(byte[] key, long ttl, byte[] serializedValue)
Response<String>	TransactionBase.restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	TransactionBase.restore(String key, long ttl, byte[] serializedValue)
Response<String>	TransactionBase.restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
Response<byte[]>	MultiNodePipelineBase.rpop(byte[] key)
Response<List<byte[]>>	MultiNodePipelineBase.rpop(byte[] key, int count)
Response<String>	MultiNodePipelineBase.rpop(String key)
Response<List<String>>	MultiNodePipelineBase.rpop(String key, int count)
Response<byte[]>	Pipeline.rpop(byte[] key)
Response<List<byte[]>>	Pipeline.rpop(byte[] key, int count)
Response<String>	Pipeline.rpop(String key)
Response<List<String>>	Pipeline.rpop(String key, int count)
Response<byte[]>	TransactionBase.rpop(byte[] key)
Response<List<byte[]>>	TransactionBase.rpop(byte[] key, int count)
Response<String>	TransactionBase.rpop(String key)
Response<List<String>>	TransactionBase.rpop(String key, int count)
Response<byte[]>	MultiNodePipelineBase.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	MultiNodePipelineBase.rpoplpush(String srcKey, String dstKey)
Response<byte[]>	Pipeline.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	Pipeline.rpoplpush(String srcKey, String dstKey)
Response<byte[]>	TransactionBase.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	TransactionBase.rpoplpush(String srcKey, String dstKey)
Response<Long>	MultiNodePipelineBase.rpush(byte[] key, byte[]... args)
Response<Long>	MultiNodePipelineBase.rpush(String key, String... string)
Response<Long>	Pipeline.rpush(byte[] key, byte[]... args)
Response<Long>	Pipeline.rpush(String key, String... string)
Response<Long>	TransactionBase.rpush(byte[] key, byte[]... args)
Response<Long>	TransactionBase.rpush(String key, String... string)
Response<Long>	MultiNodePipelineBase.rpushx(byte[] key, byte[]... args)
Response<Long>	MultiNodePipelineBase.rpushx(String key, String... strings)
Response<Long>	Pipeline.rpushx(byte[] key, byte[]... args)
Response<Long>	Pipeline.rpushx(String key, String... strings)
Response<Long>	TransactionBase.rpushx(byte[] key, byte[]... args)
Response<Long>	TransactionBase.rpushx(String key, String... strings)
Response<Long>	MultiNodePipelineBase.sadd(byte[] key, byte[]... members)
Response<Long>	MultiNodePipelineBase.sadd(String key, String... members)
Response<Long>	Pipeline.sadd(byte[] key, byte[]... members)
Response<Long>	Pipeline.sadd(String key, String... members)
Response<Long>	TransactionBase.sadd(byte[] key, byte[]... members)
Response<Long>	TransactionBase.sadd(String key, String... members)
Response<ScanResult<byte[]>>	MultiNodePipelineBase.scan(byte[] cursor)
Response<ScanResult<byte[]>>	MultiNodePipelineBase.scan(byte[] cursor, ScanParams params)
Response<ScanResult<byte[]>>	MultiNodePipelineBase.scan(byte[] cursor, ScanParams params, byte[] type)
Response<ScanResult<String>>	MultiNodePipelineBase.scan(String cursor)
Response<ScanResult<String>>	MultiNodePipelineBase.scan(String cursor, ScanParams params)
Response<ScanResult<String>>	MultiNodePipelineBase.scan(String cursor, ScanParams params, String type)
Response<ScanResult<byte[]>>	Pipeline.scan(byte[] cursor)
Response<ScanResult<byte[]>>	Pipeline.scan(byte[] cursor, ScanParams params)
Response<ScanResult<byte[]>>	Pipeline.scan(byte[] cursor, ScanParams params, byte[] type)
Response<ScanResult<String>>	Pipeline.scan(String cursor)
Response<ScanResult<String>>	Pipeline.scan(String cursor, ScanParams params)
Response<ScanResult<String>>	Pipeline.scan(String cursor, ScanParams params, String type)
Response<ScanResult<byte[]>>	TransactionBase.scan(byte[] cursor)
Response<ScanResult<byte[]>>	TransactionBase.scan(byte[] cursor, ScanParams params)
Response<ScanResult<byte[]>>	TransactionBase.scan(byte[] cursor, ScanParams params, byte[] type)
Response<ScanResult<String>>	TransactionBase.scan(String cursor)
Response<ScanResult<String>>	TransactionBase.scan(String cursor, ScanParams params)
Response<ScanResult<String>>	TransactionBase.scan(String cursor, ScanParams params, String type)
Response<Long>	MultiNodePipelineBase.scard(byte[] key)
Response<Long>	MultiNodePipelineBase.scard(String key)
Response<Long>	Pipeline.scard(byte[] key)
Response<Long>	Pipeline.scard(String key)
Response<Long>	TransactionBase.scard(byte[] key)
Response<Long>	TransactionBase.scard(String key)
Response<List<Boolean>>	MultiNodePipelineBase.scriptExists(byte[] sampleKey, byte[]... sha1s)
Response<List<Boolean>>	MultiNodePipelineBase.scriptExists(String sampleKey, String... sha1)
Response<List<Boolean>>	Pipeline.scriptExists(byte[] sampleKey, byte[]... sha1s)
Response<List<Boolean>>	Pipeline.scriptExists(String sampleKey, String... sha1)
Response<List<Boolean>>	TransactionBase.scriptExists(byte[] sampleKey, byte[]... sha1s)
Response<List<Boolean>>	TransactionBase.scriptExists(String sampleKey, String... sha1)
Response<String>	MultiNodePipelineBase.scriptFlush(byte[] sampleKey)
Response<String>	MultiNodePipelineBase.scriptFlush(byte[] sampleKey, FlushMode flushMode)
Response<String>	MultiNodePipelineBase.scriptFlush(String sampleKey)
Response<String>	MultiNodePipelineBase.scriptFlush(String sampleKey, FlushMode flushMode)
Response<String>	Pipeline.scriptFlush(byte[] sampleKey)
Response<String>	Pipeline.scriptFlush(byte[] sampleKey, FlushMode flushMode)
Response<String>	Pipeline.scriptFlush(String sampleKey)
Response<String>	Pipeline.scriptFlush(String sampleKey, FlushMode flushMode)
Response<String>	TransactionBase.scriptFlush(byte[] sampleKey)
Response<String>	TransactionBase.scriptFlush(byte[] sampleKey, FlushMode flushMode)
Response<String>	TransactionBase.scriptFlush(String sampleKey)
Response<String>	TransactionBase.scriptFlush(String sampleKey, FlushMode flushMode)
Response<String>	MultiNodePipelineBase.scriptKill(byte[] sampleKey)
Response<String>	MultiNodePipelineBase.scriptKill(String sampleKey)
Response<String>	Pipeline.scriptKill(byte[] sampleKey)
Response<String>	Pipeline.scriptKill(String sampleKey)
Response<String>	TransactionBase.scriptKill(byte[] sampleKey)
Response<String>	TransactionBase.scriptKill(String sampleKey)
Response<byte[]>	MultiNodePipelineBase.scriptLoad(byte[] script, byte[] sampleKey)
Response<String>	MultiNodePipelineBase.scriptLoad(String script, String sampleKey)
Response<byte[]>	Pipeline.scriptLoad(byte[] script, byte[] sampleKey)
Response<String>	Pipeline.scriptLoad(String script, String sampleKey)
Response<byte[]>	TransactionBase.scriptLoad(byte[] script, byte[] sampleKey)
Response<String>	TransactionBase.scriptLoad(String script, String sampleKey)
Response<Set<byte[]>>	MultiNodePipelineBase.sdiff(byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.sdiff(String... keys)
Response<Set<byte[]>>	Pipeline.sdiff(byte[]... keys)
Response<Set<String>>	Pipeline.sdiff(String... keys)
Response<Set<byte[]>>	TransactionBase.sdiff(byte[]... keys)
Response<Set<String>>	TransactionBase.sdiff(String... keys)
Response<Long>	MultiNodePipelineBase.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiNodePipelineBase.sdiffstore(String dstKey, String... keys)
Response<Long>	Pipeline.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	Pipeline.sdiffstore(String dstKey, String... keys)
Response<Long>	TransactionBase.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	TransactionBase.sdiffstore(String dstKey, String... keys)
Response<String>	Pipeline.select(int index)
Response<Object>	Pipeline.sendCommand(CommandArguments args)
Response<Object>	Pipeline.sendCommand(ProtocolCommand cmd, byte[]... args)
Response<Object>	Pipeline.sendCommand(ProtocolCommand cmd, String... args)
Response<Object>	TransactionBase.sendCommand(CommandArguments args)
Response<Object>	TransactionBase.sendCommand(ProtocolCommand cmd, byte[]... args)
Response<Object>	TransactionBase.sendCommand(ProtocolCommand cmd, String... args)
Response<String>	MultiNodePipelineBase.set(byte[] key, byte[] value)
Response<String>	MultiNodePipelineBase.set(byte[] key, byte[] value, SetParams params)
Response<String>	MultiNodePipelineBase.set(String key, String value)
Response<String>	MultiNodePipelineBase.set(String key, String value, SetParams params)
Response<String>	Pipeline.set(byte[] key, byte[] value)
Response<String>	Pipeline.set(byte[] key, byte[] value, SetParams params)
Response<String>	Pipeline.set(String key, String value)
Response<String>	Pipeline.set(String key, String value, SetParams params)
Response<String>	TransactionBase.set(byte[] key, byte[] value)
Response<String>	TransactionBase.set(byte[] key, byte[] value, SetParams params)
Response<String>	TransactionBase.set(String key, String value)
Response<String>	TransactionBase.set(String key, String value, SetParams params)
Response<Boolean>	MultiNodePipelineBase.setbit(byte[] key, long offset, boolean value)
Response<Boolean>	MultiNodePipelineBase.setbit(String key, long offset, boolean value)
Response<Boolean>	Pipeline.setbit(byte[] key, long offset, boolean value)
Response<Boolean>	Pipeline.setbit(String key, long offset, boolean value)
Response<Boolean>	TransactionBase.setbit(byte[] key, long offset, boolean value)
Response<Boolean>	TransactionBase.setbit(String key, long offset, boolean value)
Response<String>	MultiNodePipelineBase.setex(byte[] key, long seconds, byte[] value)
Response<String>	MultiNodePipelineBase.setex(String key, long seconds, String value)
Response<String>	Pipeline.setex(byte[] key, long seconds, byte[] value)
Response<String>	Pipeline.setex(String key, long seconds, String value)
Response<String>	TransactionBase.setex(byte[] key, long seconds, byte[] value)
Response<String>	TransactionBase.setex(String key, long seconds, String value)
Response<byte[]>	MultiNodePipelineBase.setGet(byte[] key, byte[] value, SetParams params)
Response<String>	MultiNodePipelineBase.setGet(String key, String value, SetParams params)
Response<byte[]>	Pipeline.setGet(byte[] key, byte[] value, SetParams params)
Response<String>	Pipeline.setGet(String key, String value, SetParams params)
Response<byte[]>	TransactionBase.setGet(byte[] key, byte[] value, SetParams params)
Response<String>	TransactionBase.setGet(String key, String value, SetParams params)
Response<Long>	MultiNodePipelineBase.setnx(byte[] key, byte[] value)
Response<Long>	MultiNodePipelineBase.setnx(String key, String value)
Response<Long>	Pipeline.setnx(byte[] key, byte[] value)
Response<Long>	Pipeline.setnx(String key, String value)
Response<Long>	TransactionBase.setnx(byte[] key, byte[] value)
Response<Long>	TransactionBase.setnx(String key, String value)
Response<Long>	MultiNodePipelineBase.setrange(byte[] key, long offset, byte[] value)
Response<Long>	MultiNodePipelineBase.setrange(String key, long offset, String value)
Response<Long>	Pipeline.setrange(byte[] key, long offset, byte[] value)
Response<Long>	Pipeline.setrange(String key, long offset, String value)
Response<Long>	TransactionBase.setrange(byte[] key, long offset, byte[] value)
Response<Long>	TransactionBase.setrange(String key, long offset, String value)
Response<Set<byte[]>>	MultiNodePipelineBase.sinter(byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.sinter(String... keys)
Response<Set<byte[]>>	Pipeline.sinter(byte[]... keys)
Response<Set<String>>	Pipeline.sinter(String... keys)
Response<Set<byte[]>>	TransactionBase.sinter(byte[]... keys)
Response<Set<String>>	TransactionBase.sinter(String... keys)
Response<Long>	MultiNodePipelineBase.sintercard(byte[]... keys)
Response<Long>	MultiNodePipelineBase.sintercard(int limit, byte[]... keys)
Response<Long>	MultiNodePipelineBase.sintercard(int limit, String... keys)
Response<Long>	MultiNodePipelineBase.sintercard(String... keys)
Response<Long>	Pipeline.sintercard(byte[]... keys)
Response<Long>	Pipeline.sintercard(int limit, byte[]... keys)
Response<Long>	Pipeline.sintercard(int limit, String... keys)
Response<Long>	Pipeline.sintercard(String... keys)
Response<Long>	TransactionBase.sintercard(byte[]... keys)
Response<Long>	TransactionBase.sintercard(int limit, byte[]... keys)
Response<Long>	TransactionBase.sintercard(int limit, String... keys)
Response<Long>	TransactionBase.sintercard(String... keys)
Response<Long>	MultiNodePipelineBase.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiNodePipelineBase.sinterstore(String dstKey, String... keys)
Response<Long>	Pipeline.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	Pipeline.sinterstore(String dstKey, String... keys)
Response<Long>	TransactionBase.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	TransactionBase.sinterstore(String dstKey, String... keys)
Response<Boolean>	MultiNodePipelineBase.sismember(byte[] key, byte[] member)
Response<Boolean>	MultiNodePipelineBase.sismember(String key, String member)
Response<Boolean>	Pipeline.sismember(byte[] key, byte[] member)
Response<Boolean>	Pipeline.sismember(String key, String member)
Response<Boolean>	TransactionBase.sismember(byte[] key, byte[] member)
Response<Boolean>	TransactionBase.sismember(String key, String member)
Response<Set<byte[]>>	MultiNodePipelineBase.smembers(byte[] key)
Response<Set<String>>	MultiNodePipelineBase.smembers(String key)
Response<Set<byte[]>>	Pipeline.smembers(byte[] key)
Response<Set<String>>	Pipeline.smembers(String key)
Response<Set<byte[]>>	TransactionBase.smembers(byte[] key)
Response<Set<String>>	TransactionBase.smembers(String key)
Response<List<Boolean>>	MultiNodePipelineBase.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	MultiNodePipelineBase.smismember(String key, String... members)
Response<List<Boolean>>	Pipeline.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	Pipeline.smismember(String key, String... members)
Response<List<Boolean>>	TransactionBase.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	TransactionBase.smismember(String key, String... members)
Response<Long>	MultiNodePipelineBase.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	MultiNodePipelineBase.smove(String srcKey, String dstKey, String member)
Response<Long>	Pipeline.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	Pipeline.smove(String srcKey, String dstKey, String member)
Response<Long>	TransactionBase.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	TransactionBase.smove(String srcKey, String dstKey, String member)
Response<List<byte[]>>	MultiNodePipelineBase.sort(byte[] key)
Response<Long>	MultiNodePipelineBase.sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	MultiNodePipelineBase.sort(byte[] key, SortingParams sortingParams)
Response<Long>	MultiNodePipelineBase.sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
Response<List<String>>	MultiNodePipelineBase.sort(String key)
Response<Long>	MultiNodePipelineBase.sort(String key, String dstKey)
Response<List<String>>	MultiNodePipelineBase.sort(String key, SortingParams sortingParams)
Response<Long>	MultiNodePipelineBase.sort(String key, SortingParams sortingParams, String dstKey)
Response<List<byte[]>>	Pipeline.sort(byte[] key)
Response<Long>	Pipeline.sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	Pipeline.sort(byte[] key, SortingParams sortingParams)
Response<Long>	Pipeline.sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
Response<List<String>>	Pipeline.sort(String key)
Response<Long>	Pipeline.sort(String key, String dstKey)
Response<List<String>>	Pipeline.sort(String key, SortingParams sortingParams)
Response<Long>	Pipeline.sort(String key, SortingParams sortingParams, String dstKey)
Response<List<byte[]>>	TransactionBase.sort(byte[] key)
Response<Long>	TransactionBase.sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	TransactionBase.sort(byte[] key, SortingParams sortingParams)
Response<Long>	TransactionBase.sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
Response<List<String>>	TransactionBase.sort(String key)
Response<Long>	TransactionBase.sort(String key, String dstKey)
Response<List<String>>	TransactionBase.sort(String key, SortingParams sortingParams)
Response<Long>	TransactionBase.sort(String key, SortingParams sortingParams, String dstKey)
Response<List<byte[]>>	MultiNodePipelineBase.sortReadonly(byte[] key, SortingParams sortingParams)
Response<List<String>>	MultiNodePipelineBase.sortReadonly(String key, SortingParams sortingParams)
Response<List<byte[]>>	Pipeline.sortReadonly(byte[] key, SortingParams sortingParams)
Response<List<String>>	Pipeline.sortReadonly(String key, SortingParams sortingParams)
Response<List<byte[]>>	TransactionBase.sortReadonly(byte[] key, SortingParams sortingParams)
Response<List<String>>	TransactionBase.sortReadonly(String key, SortingParams sortingParams)
Response<byte[]>	MultiNodePipelineBase.spop(byte[] key)
Response<Set<byte[]>>	MultiNodePipelineBase.spop(byte[] key, long count)
Response<String>	MultiNodePipelineBase.spop(String key)
Response<Set<String>>	MultiNodePipelineBase.spop(String key, long count)
Response<byte[]>	Pipeline.spop(byte[] key)
Response<Set<byte[]>>	Pipeline.spop(byte[] key, long count)
Response<String>	Pipeline.spop(String key)
Response<Set<String>>	Pipeline.spop(String key, long count)
Response<byte[]>	TransactionBase.spop(byte[] key)
Response<Set<byte[]>>	TransactionBase.spop(byte[] key, long count)
Response<String>	TransactionBase.spop(String key)
Response<Set<String>>	TransactionBase.spop(String key, long count)
Response<byte[]>	MultiNodePipelineBase.srandmember(byte[] key)
Response<List<byte[]>>	MultiNodePipelineBase.srandmember(byte[] key, int count)
Response<String>	MultiNodePipelineBase.srandmember(String key)
Response<List<String>>	MultiNodePipelineBase.srandmember(String key, int count)
Response<byte[]>	Pipeline.srandmember(byte[] key)
Response<List<byte[]>>	Pipeline.srandmember(byte[] key, int count)
Response<String>	Pipeline.srandmember(String key)
Response<List<String>>	Pipeline.srandmember(String key, int count)
Response<byte[]>	TransactionBase.srandmember(byte[] key)
Response<List<byte[]>>	TransactionBase.srandmember(byte[] key, int count)
Response<String>	TransactionBase.srandmember(String key)
Response<List<String>>	TransactionBase.srandmember(String key, int count)
Response<Long>	MultiNodePipelineBase.srem(byte[] key, byte[]... members)
Response<Long>	MultiNodePipelineBase.srem(String key, String... members)
Response<Long>	Pipeline.srem(byte[] key, byte[]... members)
Response<Long>	Pipeline.srem(String key, String... members)
Response<Long>	TransactionBase.srem(byte[] key, byte[]... members)
Response<Long>	TransactionBase.srem(String key, String... members)
Response<ScanResult<byte[]>>	MultiNodePipelineBase.sscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<String>>	MultiNodePipelineBase.sscan(String key, String cursor, ScanParams params)
Response<ScanResult<byte[]>>	Pipeline.sscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<String>>	Pipeline.sscan(String key, String cursor, ScanParams params)
Response<ScanResult<byte[]>>	TransactionBase.sscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<String>>	TransactionBase.sscan(String key, String cursor, ScanParams params)
Response<LCSMatchResult>	MultiNodePipelineBase.strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	MultiNodePipelineBase.strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	Pipeline.strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	Pipeline.strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	TransactionBase.strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	TransactionBase.strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	MultiNodePipelineBase.strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	MultiNodePipelineBase.strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	Pipeline.strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	Pipeline.strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	TransactionBase.strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	TransactionBase.strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params)
Response<Long>	MultiNodePipelineBase.strlen(byte[] key)
Response<Long>	MultiNodePipelineBase.strlen(String key)
Response<Long>	Pipeline.strlen(byte[] key)
Response<Long>	Pipeline.strlen(String key)
Response<Long>	TransactionBase.strlen(byte[] key)
Response<Long>	TransactionBase.strlen(String key)
Response<byte[]>	MultiNodePipelineBase.substr(byte[] key, int start, int end)
Response<String>	MultiNodePipelineBase.substr(String key, int start, int end)
Response<byte[]>	Pipeline.substr(byte[] key, int start, int end)
Response<String>	Pipeline.substr(String key, int start, int end)
Response<byte[]>	TransactionBase.substr(byte[] key, int start, int end)
Response<String>	TransactionBase.substr(String key, int start, int end)
Response<Set<byte[]>>	MultiNodePipelineBase.sunion(byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.sunion(String... keys)
Response<Set<byte[]>>	Pipeline.sunion(byte[]... keys)
Response<Set<String>>	Pipeline.sunion(String... keys)
Response<Set<byte[]>>	TransactionBase.sunion(byte[]... keys)
Response<Set<String>>	TransactionBase.sunion(String... keys)
Response<Long>	MultiNodePipelineBase.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiNodePipelineBase.sunionstore(String dstKey, String... keys)
Response<Long>	Pipeline.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	Pipeline.sunionstore(String dstKey, String... keys)
Response<Long>	TransactionBase.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	TransactionBase.sunionstore(String dstKey, String... keys)
Response<String>	Pipeline.swapDB(int index1, int index2)
Response<String>	MultiNodePipelineBase.tdigestAdd(String key, double... values)
Response<String>	Pipeline.tdigestAdd(String key, double... values)
Response<String>	TransactionBase.tdigestAdd(String key, double... values)
Response<List<Double>>	MultiNodePipelineBase.tdigestByRank(String key, long... ranks)
Response<List<Double>>	Pipeline.tdigestByRank(String key, long... ranks)
Response<List<Double>>	TransactionBase.tdigestByRank(String key, long... ranks)
Response<List<Double>>	MultiNodePipelineBase.tdigestByRevRank(String key, long... ranks)
Response<List<Double>>	Pipeline.tdigestByRevRank(String key, long... ranks)
Response<List<Double>>	TransactionBase.tdigestByRevRank(String key, long... ranks)
Response<List<Double>>	MultiNodePipelineBase.tdigestCDF(String key, double... values)
Response<List<Double>>	Pipeline.tdigestCDF(String key, double... values)
Response<List<Double>>	TransactionBase.tdigestCDF(String key, double... values)
Response<String>	MultiNodePipelineBase.tdigestCreate(String key)
Response<String>	MultiNodePipelineBase.tdigestCreate(String key, int compression)
Response<String>	Pipeline.tdigestCreate(String key)
Response<String>	Pipeline.tdigestCreate(String key, int compression)
Response<String>	TransactionBase.tdigestCreate(String key)
Response<String>	TransactionBase.tdigestCreate(String key, int compression)
Response<Map<String,Object>>	MultiNodePipelineBase.tdigestInfo(String key)
Response<Map<String,Object>>	Pipeline.tdigestInfo(String key)
Response<Map<String,Object>>	TransactionBase.tdigestInfo(String key)
Response<Double>	MultiNodePipelineBase.tdigestMax(String key)
Response<Double>	Pipeline.tdigestMax(String key)
Response<Double>	TransactionBase.tdigestMax(String key)
Response<String>	MultiNodePipelineBase.tdigestMerge(String destinationKey, String... sourceKeys)
Response<String>	MultiNodePipelineBase.tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys)
Response<String>	Pipeline.tdigestMerge(String destinationKey, String... sourceKeys)
Response<String>	Pipeline.tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys)
Response<String>	TransactionBase.tdigestMerge(String destinationKey, String... sourceKeys)
Response<String>	TransactionBase.tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys)
Response<Double>	MultiNodePipelineBase.tdigestMin(String key)
Response<Double>	Pipeline.tdigestMin(String key)
Response<Double>	TransactionBase.tdigestMin(String key)
Response<List<Double>>	MultiNodePipelineBase.tdigestQuantile(String key, double... quantiles)
Response<List<Double>>	Pipeline.tdigestQuantile(String key, double... quantiles)
Response<List<Double>>	TransactionBase.tdigestQuantile(String key, double... quantiles)
Response<List<Long>>	MultiNodePipelineBase.tdigestRank(String key, double... values)
Response<List<Long>>	Pipeline.tdigestRank(String key, double... values)
Response<List<Long>>	TransactionBase.tdigestRank(String key, double... values)
Response<String>	MultiNodePipelineBase.tdigestReset(String key)
Response<String>	Pipeline.tdigestReset(String key)
Response<String>	TransactionBase.tdigestReset(String key)
Response<List<Long>>	MultiNodePipelineBase.tdigestRevRank(String key, double... values)
Response<List<Long>>	Pipeline.tdigestRevRank(String key, double... values)
Response<List<Long>>	TransactionBase.tdigestRevRank(String key, double... values)
Response<Double>	MultiNodePipelineBase.tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile)
Response<Double>	Pipeline.tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile)
Response<Double>	TransactionBase.tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile)
Response<List<String>>	Pipeline.time()
Response<List<String>>	MultiNodePipelineBase.topkAdd(String key, String... items)
Response<List<String>>	Pipeline.topkAdd(String key, String... items)
Response<List<String>>	TransactionBase.topkAdd(String key, String... items)
Response<List<Long>>	MultiNodePipelineBase.topkCount(String key, String... items)
Response<List<Long>>	Pipeline.topkCount(String key, String... items)
Response<List<Long>>	TransactionBase.topkCount(String key, String... items)
Response<List<String>>	MultiNodePipelineBase.topkIncrBy(String key, Map<String,Long> itemIncrements)
Response<List<String>>	Pipeline.topkIncrBy(String key, Map<String,Long> itemIncrements)
Response<List<String>>	TransactionBase.topkIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	MultiNodePipelineBase.topkInfo(String key)
Response<Map<String,Object>>	Pipeline.topkInfo(String key)
Response<Map<String,Object>>	TransactionBase.topkInfo(String key)
Response<List<String>>	MultiNodePipelineBase.topkList(String key)
Response<List<String>>	Pipeline.topkList(String key)
Response<List<String>>	TransactionBase.topkList(String key)
Response<Map<String,Long>>	MultiNodePipelineBase.topkListWithCount(String key)
Response<Map<String,Long>>	Pipeline.topkListWithCount(String key)
Response<Map<String,Long>>	TransactionBase.topkListWithCount(String key)
Response<List<Boolean>>	MultiNodePipelineBase.topkQuery(String key, String... items)
Response<List<Boolean>>	Pipeline.topkQuery(String key, String... items)
Response<List<Boolean>>	TransactionBase.topkQuery(String key, String... items)
Response<String>	MultiNodePipelineBase.topkReserve(String key, long topk)
Response<String>	MultiNodePipelineBase.topkReserve(String key, long topk, long width, long depth, double decay)
Response<String>	Pipeline.topkReserve(String key, long topk)
Response<String>	Pipeline.topkReserve(String key, long topk, long width, long depth, double decay)
Response<String>	TransactionBase.topkReserve(String key, long topk)
Response<String>	TransactionBase.topkReserve(String key, long topk, long width, long depth, double decay)
Response<Long>	MultiNodePipelineBase.touch(byte[] key)
Response<Long>	MultiNodePipelineBase.touch(byte[]... keys)
Response<Long>	MultiNodePipelineBase.touch(String key)
Response<Long>	MultiNodePipelineBase.touch(String... keys)
Response<Long>	Pipeline.touch(byte[] key)
Response<Long>	Pipeline.touch(byte[]... keys)
Response<Long>	Pipeline.touch(String key)
Response<Long>	Pipeline.touch(String... keys)
Response<Long>	TransactionBase.touch(byte[] key)
Response<Long>	TransactionBase.touch(byte[]... keys)
Response<Long>	TransactionBase.touch(String key)
Response<Long>	TransactionBase.touch(String... keys)
Response<Long>	MultiNodePipelineBase.tsAdd(String key, double value)
Response<Long>	MultiNodePipelineBase.tsAdd(String key, long timestamp, double value)
Response<Long>	MultiNodePipelineBase.tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
Response<Long>	Pipeline.tsAdd(String key, double value)
Response<Long>	Pipeline.tsAdd(String key, long timestamp, double value)
Response<Long>	Pipeline.tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
Response<Long>	TransactionBase.tsAdd(String key, double value)
Response<Long>	TransactionBase.tsAdd(String key, long timestamp, double value)
Response<Long>	TransactionBase.tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
Response<String>	MultiNodePipelineBase.tsAlter(String key, TSAlterParams alterParams)
Response<String>	Pipeline.tsAlter(String key, TSAlterParams alterParams)
Response<String>	TransactionBase.tsAlter(String key, TSAlterParams alterParams)
Response<String>	MultiNodePipelineBase.tsCreate(String key)
Response<String>	MultiNodePipelineBase.tsCreate(String key, TSCreateParams createParams)
Response<String>	Pipeline.tsCreate(String key)
Response<String>	Pipeline.tsCreate(String key, TSCreateParams createParams)
Response<String>	TransactionBase.tsCreate(String key)
Response<String>	TransactionBase.tsCreate(String key, TSCreateParams createParams)
Response<String>	MultiNodePipelineBase.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
Response<String>	MultiNodePipelineBase.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp)
Response<String>	Pipeline.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
Response<String>	Pipeline.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp)
Response<String>	TransactionBase.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
Response<String>	TransactionBase.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp)
Response<Long>	MultiNodePipelineBase.tsDecrBy(String key, double value)
Response<Long>	MultiNodePipelineBase.tsDecrBy(String key, double value, long timestamp)
Response<Long>	Pipeline.tsDecrBy(String key, double value)
Response<Long>	Pipeline.tsDecrBy(String key, double value, long timestamp)
Response<Long>	TransactionBase.tsDecrBy(String key, double value)
Response<Long>	TransactionBase.tsDecrBy(String key, double value, long timestamp)
Response<Long>	MultiNodePipelineBase.tsDel(String key, long fromTimestamp, long toTimestamp)
Response<Long>	Pipeline.tsDel(String key, long fromTimestamp, long toTimestamp)
Response<Long>	TransactionBase.tsDel(String key, long fromTimestamp, long toTimestamp)
Response<String>	MultiNodePipelineBase.tsDeleteRule(String sourceKey, String destKey)
Response<String>	Pipeline.tsDeleteRule(String sourceKey, String destKey)
Response<String>	TransactionBase.tsDeleteRule(String sourceKey, String destKey)
Response<TSElement>	MultiNodePipelineBase.tsGet(String key)
Response<TSElement>	MultiNodePipelineBase.tsGet(String key, TSGetParams getParams)
Response<TSElement>	Pipeline.tsGet(String key)
Response<TSElement>	Pipeline.tsGet(String key, TSGetParams getParams)
Response<TSElement>	TransactionBase.tsGet(String key)
Response<TSElement>	TransactionBase.tsGet(String key, TSGetParams getParams)
Response<Long>	MultiNodePipelineBase.tsIncrBy(String key, double value)
Response<Long>	MultiNodePipelineBase.tsIncrBy(String key, double value, long timestamp)
Response<Long>	Pipeline.tsIncrBy(String key, double value)
Response<Long>	Pipeline.tsIncrBy(String key, double value, long timestamp)
Response<Long>	TransactionBase.tsIncrBy(String key, double value)
Response<Long>	TransactionBase.tsIncrBy(String key, double value, long timestamp)
Response<List<Long>>	MultiNodePipelineBase.tsMAdd(Map.Entry<String,TSElement>... entries)
Response<List<Long>>	Pipeline.tsMAdd(Map.Entry<String,TSElement>... entries)
Response<List<Long>>	TransactionBase.tsMAdd(Map.Entry<String,TSElement>... entries)
Response<List<TSKeyValue<TSElement>>>	MultiNodePipelineBase.tsMGet(TSMGetParams multiGetParams, String... filters)
Response<List<TSKeyValue<TSElement>>>	Pipeline.tsMGet(TSMGetParams multiGetParams, String... filters)
Response<List<TSKeyValue<TSElement>>>	TransactionBase.tsMGet(TSMGetParams multiGetParams, String... filters)
Response<List<TSKeyedElements>>	MultiNodePipelineBase.tsMRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	MultiNodePipelineBase.tsMRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	Pipeline.tsMRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	Pipeline.tsMRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	TransactionBase.tsMRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	TransactionBase.tsMRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	MultiNodePipelineBase.tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	MultiNodePipelineBase.tsMRevRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	Pipeline.tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	Pipeline.tsMRevRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	TransactionBase.tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	TransactionBase.tsMRevRange(TSMRangeParams multiRangeParams)
Response<List<String>>	MultiNodePipelineBase.tsQueryIndex(String... filters)
Response<List<String>>	Pipeline.tsQueryIndex(String... filters)
Response<List<String>>	TransactionBase.tsQueryIndex(String... filters)
Response<List<TSElement>>	MultiNodePipelineBase.tsRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	MultiNodePipelineBase.tsRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	Pipeline.tsRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	Pipeline.tsRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	TransactionBase.tsRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	TransactionBase.tsRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	MultiNodePipelineBase.tsRevRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	MultiNodePipelineBase.tsRevRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	Pipeline.tsRevRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	Pipeline.tsRevRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	TransactionBase.tsRevRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	TransactionBase.tsRevRange(String key, TSRangeParams rangeParams)
Response<Long>	MultiNodePipelineBase.ttl(byte[] key)
Response<Long>	MultiNodePipelineBase.ttl(String key)
Response<Long>	Pipeline.ttl(byte[] key)
Response<Long>	Pipeline.ttl(String key)
Response<Long>	TransactionBase.ttl(byte[] key)
Response<Long>	TransactionBase.ttl(String key)
Response<String>	MultiNodePipelineBase.type(byte[] key)
Response<String>	MultiNodePipelineBase.type(String key)
Response<String>	Pipeline.type(byte[] key)
Response<String>	Pipeline.type(String key)
Response<String>	TransactionBase.type(byte[] key)
Response<String>	TransactionBase.type(String key)
Response<Long>	MultiNodePipelineBase.unlink(byte[] key)
Response<Long>	MultiNodePipelineBase.unlink(byte[]... keys)
Response<Long>	MultiNodePipelineBase.unlink(String key)
Response<Long>	MultiNodePipelineBase.unlink(String... keys)
Response<Long>	Pipeline.unlink(byte[] key)
Response<Long>	Pipeline.unlink(byte[]... keys)
Response<Long>	Pipeline.unlink(String key)
Response<Long>	Pipeline.unlink(String... keys)
Response<Long>	TransactionBase.unlink(byte[] key)
Response<Long>	TransactionBase.unlink(byte[]... keys)
Response<Long>	TransactionBase.unlink(String key)
Response<Long>	TransactionBase.unlink(String... keys)
Response<KeyValue<Long,Long>>	MultiNodePipelineBase.waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	MultiNodePipelineBase.waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	Pipeline.waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	Pipeline.waitAOF(long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	Pipeline.waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	TransactionBase.waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	TransactionBase.waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout)
Response<Long>	MultiNodePipelineBase.waitReplicas(byte[] sampleKey, int replicas, long timeout)
Response<Long>	MultiNodePipelineBase.waitReplicas(int replicas, long timeout)
Response<Long>	MultiNodePipelineBase.waitReplicas(String sampleKey, int replicas, long timeout)
Response<Long>	Pipeline.waitReplicas(byte[] sampleKey, int replicas, long timeout)
Response<Long>	Pipeline.waitReplicas(int replicas, long timeout)
Response<Long>	Pipeline.waitReplicas(String sampleKey, int replicas, long timeout)
Response<Long>	TransactionBase.waitReplicas(byte[] sampleKey, int replicas, long timeout)
Response<Long>	TransactionBase.waitReplicas(int replicas, long timeout)
Response<Long>	TransactionBase.waitReplicas(String sampleKey, int replicas, long timeout)
Response<Long>	MultiNodePipelineBase.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	MultiNodePipelineBase.xack(String key, String group, StreamEntryID... ids)
Response<Long>	Pipeline.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	Pipeline.xack(String key, String group, StreamEntryID... ids)
Response<Long>	TransactionBase.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	TransactionBase.xack(String key, String group, StreamEntryID... ids)
Response<byte[]>	MultiNodePipelineBase.xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
Response<StreamEntryID>	MultiNodePipelineBase.xadd(String key, XAddParams params, Map<String,String> hash)
Response<StreamEntryID>	MultiNodePipelineBase.xadd(String key, StreamEntryID id, Map<String,String> hash)
Response<byte[]>	Pipeline.xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
Response<StreamEntryID>	Pipeline.xadd(String key, XAddParams params, Map<String,String> hash)
Response<StreamEntryID>	Pipeline.xadd(String key, StreamEntryID id, Map<String,String> hash)
Response<byte[]>	TransactionBase.xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
Response<StreamEntryID>	TransactionBase.xadd(String key, XAddParams params, Map<String,String> hash)
Response<StreamEntryID>	TransactionBase.xadd(String key, StreamEntryID id, Map<String,String> hash)
Response<List<Object>>	MultiNodePipelineBase.xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntry>>>	MultiNodePipelineBase.xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<Object>>	Pipeline.xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntry>>>	Pipeline.xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<Object>>	TransactionBase.xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntry>>>	TransactionBase.xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<Object>>	MultiNodePipelineBase.xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntryID>>>	MultiNodePipelineBase.xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<Object>>	Pipeline.xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntryID>>>	Pipeline.xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<Object>>	TransactionBase.xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntryID>>>	TransactionBase.xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
Response<List<byte[]>>	MultiNodePipelineBase.xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntry>>	MultiNodePipelineBase.xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<List<byte[]>>	Pipeline.xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntry>>	Pipeline.xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<List<byte[]>>	TransactionBase.xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntry>>	TransactionBase.xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<List<byte[]>>	MultiNodePipelineBase.xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntryID>>	MultiNodePipelineBase.xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<List<byte[]>>	Pipeline.xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntryID>>	Pipeline.xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<List<byte[]>>	TransactionBase.xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntryID>>	TransactionBase.xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
Response<Long>	MultiNodePipelineBase.xdel(byte[] key, byte[]... ids)
Response<Long>	MultiNodePipelineBase.xdel(String key, StreamEntryID... ids)
Response<Long>	Pipeline.xdel(byte[] key, byte[]... ids)
Response<Long>	Pipeline.xdel(String key, StreamEntryID... ids)
Response<Long>	TransactionBase.xdel(byte[] key, byte[]... ids)
Response<Long>	TransactionBase.xdel(String key, StreamEntryID... ids)
Response<String>	MultiNodePipelineBase.xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
Response<String>	MultiNodePipelineBase.xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)
Response<String>	Pipeline.xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
Response<String>	Pipeline.xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)
Response<String>	TransactionBase.xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
Response<String>	TransactionBase.xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)
Response<Boolean>	MultiNodePipelineBase.xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Boolean>	MultiNodePipelineBase.xgroupCreateConsumer(String key, String groupName, String consumerName)
Response<Boolean>	Pipeline.xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Boolean>	Pipeline.xgroupCreateConsumer(String key, String groupName, String consumerName)
Response<Boolean>	TransactionBase.xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Boolean>	TransactionBase.xgroupCreateConsumer(String key, String groupName, String consumerName)
Response<Long>	MultiNodePipelineBase.xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Long>	MultiNodePipelineBase.xgroupDelConsumer(String key, String groupName, String consumerName)
Response<Long>	Pipeline.xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Long>	Pipeline.xgroupDelConsumer(String key, String groupName, String consumerName)
Response<Long>	TransactionBase.xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Long>	TransactionBase.xgroupDelConsumer(String key, String groupName, String consumerName)
Response<Long>	MultiNodePipelineBase.xgroupDestroy(byte[] key, byte[] groupName)
Response<Long>	MultiNodePipelineBase.xgroupDestroy(String key, String groupName)
Response<Long>	Pipeline.xgroupDestroy(byte[] key, byte[] groupName)
Response<Long>	Pipeline.xgroupDestroy(String key, String groupName)
Response<Long>	TransactionBase.xgroupDestroy(byte[] key, byte[] groupName)
Response<Long>	TransactionBase.xgroupDestroy(String key, String groupName)
Response<String>	MultiNodePipelineBase.xgroupSetID(byte[] key, byte[] groupName, byte[] id)
Response<String>	MultiNodePipelineBase.xgroupSetID(String key, String groupName, StreamEntryID id)
Response<String>	Pipeline.xgroupSetID(byte[] key, byte[] groupName, byte[] id)
Response<String>	Pipeline.xgroupSetID(String key, String groupName, StreamEntryID id)
Response<String>	TransactionBase.xgroupSetID(byte[] key, byte[] groupName, byte[] id)
Response<String>	TransactionBase.xgroupSetID(String key, String groupName, StreamEntryID id)
Response<List<Object>>	MultiNodePipelineBase.xinfoConsumers(byte[] key, byte[] group)
Response<List<StreamConsumersInfo>>	MultiNodePipelineBase.xinfoConsumers(String key, String group)
Response<List<Object>>	Pipeline.xinfoConsumers(byte[] key, byte[] group)
Response<List<StreamConsumersInfo>>	Pipeline.xinfoConsumers(String key, String group)
Response<List<Object>>	TransactionBase.xinfoConsumers(byte[] key, byte[] group)
Response<List<StreamConsumersInfo>>	TransactionBase.xinfoConsumers(String key, String group)
Response<List<Object>>	MultiNodePipelineBase.xinfoGroup(byte[] key)	Deprecated.
Response<List<StreamGroupInfo>>	MultiNodePipelineBase.xinfoGroup(String key)	Deprecated.
Response<List<Object>>	Pipeline.xinfoGroup(byte[] key)	Deprecated.
Response<List<StreamGroupInfo>>	Pipeline.xinfoGroup(String key)	Deprecated.
Response<List<Object>>	TransactionBase.xinfoGroup(byte[] key)	Deprecated.
Response<List<StreamGroupInfo>>	TransactionBase.xinfoGroup(String key)	Deprecated.
Response<List<Object>>	MultiNodePipelineBase.xinfoGroups(byte[] key)
Response<List<StreamGroupInfo>>	MultiNodePipelineBase.xinfoGroups(String key)
Response<List<Object>>	Pipeline.xinfoGroups(byte[] key)
Response<List<StreamGroupInfo>>	Pipeline.xinfoGroups(String key)
Response<List<Object>>	TransactionBase.xinfoGroups(byte[] key)
Response<List<StreamGroupInfo>>	TransactionBase.xinfoGroups(String key)
Response<Object>	MultiNodePipelineBase.xinfoStream(byte[] key)
Response<StreamInfo>	MultiNodePipelineBase.xinfoStream(String key)
Response<Object>	Pipeline.xinfoStream(byte[] key)
Response<StreamInfo>	Pipeline.xinfoStream(String key)
Response<Object>	TransactionBase.xinfoStream(byte[] key)
Response<StreamInfo>	TransactionBase.xinfoStream(String key)
Response<Object>	MultiNodePipelineBase.xinfoStreamFull(byte[] key)
Response<Object>	MultiNodePipelineBase.xinfoStreamFull(byte[] key, int count)
Response<StreamFullInfo>	MultiNodePipelineBase.xinfoStreamFull(String key)
Response<StreamFullInfo>	MultiNodePipelineBase.xinfoStreamFull(String key, int count)
Response<Object>	Pipeline.xinfoStreamFull(byte[] key)
Response<Object>	Pipeline.xinfoStreamFull(byte[] key, int count)
Response<StreamFullInfo>	Pipeline.xinfoStreamFull(String key)
Response<StreamFullInfo>	Pipeline.xinfoStreamFull(String key, int count)
Response<Object>	TransactionBase.xinfoStreamFull(byte[] key)
Response<Object>	TransactionBase.xinfoStreamFull(byte[] key, int count)
Response<StreamFullInfo>	TransactionBase.xinfoStreamFull(String key)
Response<StreamFullInfo>	TransactionBase.xinfoStreamFull(String key, int count)
Response<Long>	MultiNodePipelineBase.xlen(byte[] key)
Response<Long>	MultiNodePipelineBase.xlen(String key)
Response<Long>	Pipeline.xlen(byte[] key)
Response<Long>	Pipeline.xlen(String key)
Response<Long>	TransactionBase.xlen(byte[] key)
Response<Long>	TransactionBase.xlen(String key)
Response<Object>	MultiNodePipelineBase.xpending(byte[] key, byte[] groupName)
Response<List<Object>>	MultiNodePipelineBase.xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
Response<List<Object>>	MultiNodePipelineBase.xpending(byte[] key, byte[] groupName, XPendingParams params)
Response<StreamPendingSummary>	MultiNodePipelineBase.xpending(String key, String groupName)
Response<List<StreamPendingEntry>>	MultiNodePipelineBase.xpending(String key, String groupName, XPendingParams params)
Response<List<StreamPendingEntry>>	MultiNodePipelineBase.xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)
Response<Object>	Pipeline.xpending(byte[] key, byte[] groupName)
Response<List<Object>>	Pipeline.xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
Response<List<Object>>	Pipeline.xpending(byte[] key, byte[] groupName, XPendingParams params)
Response<StreamPendingSummary>	Pipeline.xpending(String key, String groupName)
Response<List<StreamPendingEntry>>	Pipeline.xpending(String key, String groupName, XPendingParams params)
Response<List<StreamPendingEntry>>	Pipeline.xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)
Response<Object>	TransactionBase.xpending(byte[] key, byte[] groupName)
Response<List<Object>>	TransactionBase.xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
Response<List<Object>>	TransactionBase.xpending(byte[] key, byte[] groupName, XPendingParams params)
Response<StreamPendingSummary>	TransactionBase.xpending(String key, String groupName)
Response<List<StreamPendingEntry>>	TransactionBase.xpending(String key, String groupName, XPendingParams params)
Response<List<StreamPendingEntry>>	TransactionBase.xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)
Response<List<Object>>	MultiNodePipelineBase.xrange(byte[] key, byte[] start, byte[] end)
Response<List<Object>>	MultiNodePipelineBase.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrange(String key, String start, String end)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrange(String key, String start, String end, int count)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrange(String key, StreamEntryID start, StreamEntryID end)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrange(String key, StreamEntryID start, StreamEntryID end, int count)
Response<List<Object>>	Pipeline.xrange(byte[] key, byte[] start, byte[] end)
Response<List<Object>>	Pipeline.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	Pipeline.xrange(String key, String start, String end)
Response<List<StreamEntry>>	Pipeline.xrange(String key, String start, String end, int count)
Response<List<StreamEntry>>	Pipeline.xrange(String key, StreamEntryID start, StreamEntryID end)
Response<List<StreamEntry>>	Pipeline.xrange(String key, StreamEntryID start, StreamEntryID end, int count)
Response<List<Object>>	TransactionBase.xrange(byte[] key, byte[] start, byte[] end)
Response<List<Object>>	TransactionBase.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	TransactionBase.xrange(String key, String start, String end)
Response<List<StreamEntry>>	TransactionBase.xrange(String key, String start, String end, int count)
Response<List<StreamEntry>>	TransactionBase.xrange(String key, StreamEntryID start, StreamEntryID end)
Response<List<StreamEntry>>	TransactionBase.xrange(String key, StreamEntryID start, StreamEntryID end, int count)
Response<List<Object>>	MultiNodePipelineBase.xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	MultiNodePipelineBase.xread(XReadParams xReadParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	Pipeline.xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	Pipeline.xread(XReadParams xReadParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	TransactionBase.xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	TransactionBase.xread(XReadParams xReadParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	MultiNodePipelineBase.xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	MultiNodePipelineBase.xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	Pipeline.xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	Pipeline.xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	TransactionBase.xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	TransactionBase.xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)
Response<List<Object>>	MultiNodePipelineBase.xrevrange(byte[] key, byte[] end, byte[] start)
Response<List<Object>>	MultiNodePipelineBase.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrevrange(String key, String end, String start)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrevrange(String key, String end, String start, int count)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrevrange(String key, StreamEntryID end, StreamEntryID start)
Response<List<StreamEntry>>	MultiNodePipelineBase.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
Response<List<Object>>	Pipeline.xrevrange(byte[] key, byte[] end, byte[] start)
Response<List<Object>>	Pipeline.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	Pipeline.xrevrange(String key, String end, String start)
Response<List<StreamEntry>>	Pipeline.xrevrange(String key, String end, String start, int count)
Response<List<StreamEntry>>	Pipeline.xrevrange(String key, StreamEntryID end, StreamEntryID start)
Response<List<StreamEntry>>	Pipeline.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
Response<List<Object>>	TransactionBase.xrevrange(byte[] key, byte[] end, byte[] start)
Response<List<Object>>	TransactionBase.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	TransactionBase.xrevrange(String key, String end, String start)
Response<List<StreamEntry>>	TransactionBase.xrevrange(String key, String end, String start, int count)
Response<List<StreamEntry>>	TransactionBase.xrevrange(String key, StreamEntryID end, StreamEntryID start)
Response<List<StreamEntry>>	TransactionBase.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
Response<Long>	MultiNodePipelineBase.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	MultiNodePipelineBase.xtrim(byte[] key, XTrimParams params)
Response<Long>	MultiNodePipelineBase.xtrim(String key, long maxLen, boolean approximate)
Response<Long>	MultiNodePipelineBase.xtrim(String key, XTrimParams params)
Response<Long>	Pipeline.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	Pipeline.xtrim(byte[] key, XTrimParams params)
Response<Long>	Pipeline.xtrim(String key, long maxLen, boolean approximate)
Response<Long>	Pipeline.xtrim(String key, XTrimParams params)
Response<Long>	TransactionBase.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	TransactionBase.xtrim(byte[] key, XTrimParams params)
Response<Long>	TransactionBase.xtrim(String key, long maxLen, boolean approximate)
Response<Long>	TransactionBase.xtrim(String key, XTrimParams params)
Response<Long>	MultiNodePipelineBase.zadd(byte[] key, double score, byte[] member)
Response<Long>	MultiNodePipelineBase.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	MultiNodePipelineBase.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	MultiNodePipelineBase.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	MultiNodePipelineBase.zadd(String key, double score, String member)
Response<Long>	MultiNodePipelineBase.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	MultiNodePipelineBase.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	MultiNodePipelineBase.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Long>	Pipeline.zadd(byte[] key, double score, byte[] member)
Response<Long>	Pipeline.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	Pipeline.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	Pipeline.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	Pipeline.zadd(String key, double score, String member)
Response<Long>	Pipeline.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	Pipeline.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	Pipeline.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Long>	TransactionBase.zadd(byte[] key, double score, byte[] member)
Response<Long>	TransactionBase.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	TransactionBase.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	TransactionBase.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	TransactionBase.zadd(String key, double score, String member)
Response<Long>	TransactionBase.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	TransactionBase.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	TransactionBase.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Double>	MultiNodePipelineBase.zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
Response<Double>	MultiNodePipelineBase.zaddIncr(String key, double score, String member, ZAddParams params)
Response<Double>	Pipeline.zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
Response<Double>	Pipeline.zaddIncr(String key, double score, String member, ZAddParams params)
Response<Double>	TransactionBase.zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
Response<Double>	TransactionBase.zaddIncr(String key, double score, String member, ZAddParams params)
Response<Long>	MultiNodePipelineBase.zcard(byte[] key)
Response<Long>	MultiNodePipelineBase.zcard(String key)
Response<Long>	Pipeline.zcard(byte[] key)
Response<Long>	Pipeline.zcard(String key)
Response<Long>	TransactionBase.zcard(byte[] key)
Response<Long>	TransactionBase.zcard(String key)
Response<Long>	MultiNodePipelineBase.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	MultiNodePipelineBase.zcount(byte[] key, double min, double max)
Response<Long>	MultiNodePipelineBase.zcount(String key, double min, double max)
Response<Long>	MultiNodePipelineBase.zcount(String key, String min, String max)
Response<Long>	Pipeline.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	Pipeline.zcount(byte[] key, double min, double max)
Response<Long>	Pipeline.zcount(String key, double min, double max)
Response<Long>	Pipeline.zcount(String key, String min, String max)
Response<Long>	TransactionBase.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	TransactionBase.zcount(byte[] key, double min, double max)
Response<Long>	TransactionBase.zcount(String key, double min, double max)
Response<Long>	TransactionBase.zcount(String key, String min, String max)
Response<Set<byte[]>>	MultiNodePipelineBase.zdiff(byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.zdiff(String... keys)
Response<Set<byte[]>>	Pipeline.zdiff(byte[]... keys)
Response<Set<String>>	Pipeline.zdiff(String... keys)
Response<Set<byte[]>>	TransactionBase.zdiff(byte[]... keys)
Response<Set<String>>	TransactionBase.zdiff(String... keys)
Response<Long>	MultiNodePipelineBase.zdiffStore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiNodePipelineBase.zdiffStore(String dstKey, String... keys)
Response<Long>	Pipeline.zdiffStore(byte[] dstkey, byte[]... keys)
Response<Long>	Pipeline.zdiffStore(String dstKey, String... keys)
Response<Long>	TransactionBase.zdiffStore(byte[] dstkey, byte[]... keys)
Response<Long>	TransactionBase.zdiffStore(String dstKey, String... keys)
Response<Set<Tuple>>	MultiNodePipelineBase.zdiffWithScores(byte[]... keys)
Response<Set<Tuple>>	MultiNodePipelineBase.zdiffWithScores(String... keys)
Response<Set<Tuple>>	Pipeline.zdiffWithScores(byte[]... keys)
Response<Set<Tuple>>	Pipeline.zdiffWithScores(String... keys)
Response<Set<Tuple>>	TransactionBase.zdiffWithScores(byte[]... keys)
Response<Set<Tuple>>	TransactionBase.zdiffWithScores(String... keys)
Response<Double>	MultiNodePipelineBase.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	MultiNodePipelineBase.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	MultiNodePipelineBase.zincrby(String key, double increment, String member)
Response<Double>	MultiNodePipelineBase.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Double>	Pipeline.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	Pipeline.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	Pipeline.zincrby(String key, double increment, String member)
Response<Double>	Pipeline.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Double>	TransactionBase.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	TransactionBase.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	TransactionBase.zincrby(String key, double increment, String member)
Response<Double>	TransactionBase.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Set<byte[]>>	MultiNodePipelineBase.zinter(ZParams params, byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.zinter(ZParams params, String... keys)
Response<Set<byte[]>>	Pipeline.zinter(ZParams params, byte[]... keys)
Response<Set<String>>	Pipeline.zinter(ZParams params, String... keys)
Response<Set<byte[]>>	TransactionBase.zinter(ZParams params, byte[]... keys)
Response<Set<String>>	TransactionBase.zinter(ZParams params, String... keys)
Response<Long>	MultiNodePipelineBase.zintercard(byte[]... keys)
Response<Long>	MultiNodePipelineBase.zintercard(long limit, byte[]... keys)
Response<Long>	MultiNodePipelineBase.zintercard(long limit, String... keys)
Response<Long>	MultiNodePipelineBase.zintercard(String... keys)
Response<Long>	Pipeline.zintercard(byte[]... keys)
Response<Long>	Pipeline.zintercard(long limit, byte[]... keys)
Response<Long>	Pipeline.zintercard(long limit, String... keys)
Response<Long>	Pipeline.zintercard(String... keys)
Response<Long>	TransactionBase.zintercard(byte[]... keys)
Response<Long>	TransactionBase.zintercard(long limit, byte[]... keys)
Response<Long>	TransactionBase.zintercard(long limit, String... keys)
Response<Long>	TransactionBase.zintercard(String... keys)
Response<Long>	MultiNodePipelineBase.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiNodePipelineBase.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiNodePipelineBase.zinterstore(String dstKey, String... sets)
Response<Long>	MultiNodePipelineBase.zinterstore(String dstKey, ZParams params, String... sets)
Response<Long>	Pipeline.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	Pipeline.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	Pipeline.zinterstore(String dstKey, String... sets)
Response<Long>	Pipeline.zinterstore(String dstKey, ZParams params, String... sets)
Response<Long>	TransactionBase.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	TransactionBase.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	TransactionBase.zinterstore(String dstKey, String... sets)
Response<Long>	TransactionBase.zinterstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	MultiNodePipelineBase.zinterWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	MultiNodePipelineBase.zinterWithScores(ZParams params, String... keys)
Response<Set<Tuple>>	Pipeline.zinterWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	Pipeline.zinterWithScores(ZParams params, String... keys)
Response<Set<Tuple>>	TransactionBase.zinterWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	TransactionBase.zinterWithScores(ZParams params, String... keys)
Response<Long>	MultiNodePipelineBase.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	MultiNodePipelineBase.zlexcount(String key, String min, String max)
Response<Long>	Pipeline.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	Pipeline.zlexcount(String key, String min, String max)
Response<Long>	TransactionBase.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	TransactionBase.zlexcount(String key, String min, String max)
Response<KeyValue<byte[],List<Tuple>>>	MultiNodePipelineBase.zmpop(SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	MultiNodePipelineBase.zmpop(SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	MultiNodePipelineBase.zmpop(SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	MultiNodePipelineBase.zmpop(SortedSetOption option, String... keys)
Response<KeyValue<byte[],List<Tuple>>>	Pipeline.zmpop(SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	Pipeline.zmpop(SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	Pipeline.zmpop(SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	Pipeline.zmpop(SortedSetOption option, String... keys)
Response<KeyValue<byte[],List<Tuple>>>	TransactionBase.zmpop(SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	TransactionBase.zmpop(SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	TransactionBase.zmpop(SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	TransactionBase.zmpop(SortedSetOption option, String... keys)
Response<List<Double>>	MultiNodePipelineBase.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	MultiNodePipelineBase.zmscore(String key, String... members)
Response<List<Double>>	Pipeline.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	Pipeline.zmscore(String key, String... members)
Response<List<Double>>	TransactionBase.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	TransactionBase.zmscore(String key, String... members)
Response<Tuple>	MultiNodePipelineBase.zpopmax(byte[] key)
Response<List<Tuple>>	MultiNodePipelineBase.zpopmax(byte[] key, int count)
Response<Tuple>	MultiNodePipelineBase.zpopmax(String key)
Response<List<Tuple>>	MultiNodePipelineBase.zpopmax(String key, int count)
Response<Tuple>	Pipeline.zpopmax(byte[] key)
Response<List<Tuple>>	Pipeline.zpopmax(byte[] key, int count)
Response<Tuple>	Pipeline.zpopmax(String key)
Response<List<Tuple>>	Pipeline.zpopmax(String key, int count)
Response<Tuple>	TransactionBase.zpopmax(byte[] key)
Response<List<Tuple>>	TransactionBase.zpopmax(byte[] key, int count)
Response<Tuple>	TransactionBase.zpopmax(String key)
Response<List<Tuple>>	TransactionBase.zpopmax(String key, int count)
Response<Tuple>	MultiNodePipelineBase.zpopmin(byte[] key)
Response<List<Tuple>>	MultiNodePipelineBase.zpopmin(byte[] key, int count)
Response<Tuple>	MultiNodePipelineBase.zpopmin(String key)
Response<List<Tuple>>	MultiNodePipelineBase.zpopmin(String key, int count)
Response<Tuple>	Pipeline.zpopmin(byte[] key)
Response<List<Tuple>>	Pipeline.zpopmin(byte[] key, int count)
Response<Tuple>	Pipeline.zpopmin(String key)
Response<List<Tuple>>	Pipeline.zpopmin(String key, int count)
Response<Tuple>	TransactionBase.zpopmin(byte[] key)
Response<List<Tuple>>	TransactionBase.zpopmin(byte[] key, int count)
Response<Tuple>	TransactionBase.zpopmin(String key)
Response<List<Tuple>>	TransactionBase.zpopmin(String key, int count)
Response<byte[]>	MultiNodePipelineBase.zrandmember(byte[] key)
Response<List<byte[]>>	MultiNodePipelineBase.zrandmember(byte[] key, long count)
Response<String>	MultiNodePipelineBase.zrandmember(String key)
Response<List<String>>	MultiNodePipelineBase.zrandmember(String key, long count)
Response<byte[]>	Pipeline.zrandmember(byte[] key)
Response<List<byte[]>>	Pipeline.zrandmember(byte[] key, long count)
Response<String>	Pipeline.zrandmember(String key)
Response<List<String>>	Pipeline.zrandmember(String key, long count)
Response<byte[]>	TransactionBase.zrandmember(byte[] key)
Response<List<byte[]>>	TransactionBase.zrandmember(byte[] key, long count)
Response<String>	TransactionBase.zrandmember(String key)
Response<List<String>>	TransactionBase.zrandmember(String key, long count)
Response<List<Tuple>>	MultiNodePipelineBase.zrandmemberWithScores(byte[] key, long count)
Response<List<Tuple>>	MultiNodePipelineBase.zrandmemberWithScores(String key, long count)
Response<List<Tuple>>	Pipeline.zrandmemberWithScores(byte[] key, long count)
Response<List<Tuple>>	Pipeline.zrandmemberWithScores(String key, long count)
Response<List<Tuple>>	TransactionBase.zrandmemberWithScores(byte[] key, long count)
Response<List<Tuple>>	TransactionBase.zrandmemberWithScores(String key, long count)
Response<List<byte[]>>	MultiNodePipelineBase.zrange(byte[] key, long start, long stop)
Response<List<byte[]>>	MultiNodePipelineBase.zrange(byte[] key, ZRangeParams zRangeParams)
Response<List<String>>	MultiNodePipelineBase.zrange(String key, long start, long stop)
Response<List<String>>	MultiNodePipelineBase.zrange(String key, ZRangeParams zRangeParams)
Response<List<byte[]>>	Pipeline.zrange(byte[] key, long start, long stop)
Response<List<byte[]>>	Pipeline.zrange(byte[] key, ZRangeParams zRangeParams)
Response<List<String>>	Pipeline.zrange(String key, long start, long stop)
Response<List<String>>	Pipeline.zrange(String key, ZRangeParams zRangeParams)
Response<List<byte[]>>	TransactionBase.zrange(byte[] key, long start, long stop)
Response<List<byte[]>>	TransactionBase.zrange(byte[] key, ZRangeParams zRangeParams)
Response<List<String>>	TransactionBase.zrange(String key, long start, long stop)
Response<List<String>>	TransactionBase.zrange(String key, ZRangeParams zRangeParams)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrangeByLex(String key, String min, String max)
Response<List<String>>	MultiNodePipelineBase.zrangeByLex(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	Pipeline.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	Pipeline.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<String>>	Pipeline.zrangeByLex(String key, String min, String max)
Response<List<String>>	Pipeline.zrangeByLex(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	TransactionBase.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<String>>	TransactionBase.zrangeByLex(String key, String min, String max)
Response<List<String>>	TransactionBase.zrangeByLex(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByScore(byte[] key, double min, double max)
Response<List<byte[]>>	MultiNodePipelineBase.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrangeByScore(String key, double min, double max)
Response<List<String>>	MultiNodePipelineBase.zrangeByScore(String key, double min, double max, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrangeByScore(String key, String min, String max)
Response<List<String>>	MultiNodePipelineBase.zrangeByScore(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	Pipeline.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	Pipeline.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<byte[]>>	Pipeline.zrangeByScore(byte[] key, double min, double max)
Response<List<byte[]>>	Pipeline.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<List<String>>	Pipeline.zrangeByScore(String key, double min, double max)
Response<List<String>>	Pipeline.zrangeByScore(String key, double min, double max, int offset, int count)
Response<List<String>>	Pipeline.zrangeByScore(String key, String min, String max)
Response<List<String>>	Pipeline.zrangeByScore(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	TransactionBase.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrangeByScore(byte[] key, double min, double max)
Response<List<byte[]>>	TransactionBase.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<List<String>>	TransactionBase.zrangeByScore(String key, double min, double max)
Response<List<String>>	TransactionBase.zrangeByScore(String key, double min, double max, int offset, int count)
Response<List<String>>	TransactionBase.zrangeByScore(String key, String min, String max)
Response<List<String>>	TransactionBase.zrangeByScore(String key, String min, String max, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(String key, double min, double max)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(String key, String min, String max)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(String key, double min, double max)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(String key, String min, String max)
Response<List<Tuple>>	Pipeline.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(String key, double min, double max)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(String key, String min, String max)
Response<List<Tuple>>	TransactionBase.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Long>	MultiNodePipelineBase.zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
Response<Long>	MultiNodePipelineBase.zrangestore(String dest, String src, ZRangeParams zRangeParams)
Response<Long>	Pipeline.zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
Response<Long>	Pipeline.zrangestore(String dest, String src, ZRangeParams zRangeParams)
Response<Long>	TransactionBase.zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
Response<Long>	TransactionBase.zrangestore(String dest, String src, ZRangeParams zRangeParams)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	MultiNodePipelineBase.zrangeWithScores(String key, ZRangeParams zRangeParams)
Response<List<Tuple>>	Pipeline.zrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	Pipeline.zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
Response<List<Tuple>>	Pipeline.zrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	Pipeline.zrangeWithScores(String key, ZRangeParams zRangeParams)
Response<List<Tuple>>	TransactionBase.zrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	TransactionBase.zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
Response<List<Tuple>>	TransactionBase.zrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	TransactionBase.zrangeWithScores(String key, ZRangeParams zRangeParams)
Response<Long>	MultiNodePipelineBase.zrank(byte[] key, byte[] member)
Response<Long>	MultiNodePipelineBase.zrank(String key, String member)
Response<Long>	Pipeline.zrank(byte[] key, byte[] member)
Response<Long>	Pipeline.zrank(String key, String member)
Response<Long>	TransactionBase.zrank(byte[] key, byte[] member)
Response<Long>	TransactionBase.zrank(String key, String member)
Response<KeyValue<Long,Double>>	MultiNodePipelineBase.zrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	MultiNodePipelineBase.zrankWithScore(String key, String member)
Response<KeyValue<Long,Double>>	Pipeline.zrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	Pipeline.zrankWithScore(String key, String member)
Response<KeyValue<Long,Double>>	TransactionBase.zrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	TransactionBase.zrankWithScore(String key, String member)
Response<Long>	MultiNodePipelineBase.zrem(byte[] key, byte[]... members)
Response<Long>	MultiNodePipelineBase.zrem(String key, String... members)
Response<Long>	Pipeline.zrem(byte[] key, byte[]... members)
Response<Long>	Pipeline.zrem(String key, String... members)
Response<Long>	TransactionBase.zrem(byte[] key, byte[]... members)
Response<Long>	TransactionBase.zrem(String key, String... members)
Response<Long>	MultiNodePipelineBase.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	MultiNodePipelineBase.zremrangeByLex(String key, String min, String max)
Response<Long>	Pipeline.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	Pipeline.zremrangeByLex(String key, String min, String max)
Response<Long>	TransactionBase.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	TransactionBase.zremrangeByLex(String key, String min, String max)
Response<Long>	MultiNodePipelineBase.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	MultiNodePipelineBase.zremrangeByRank(String key, long start, long stop)
Response<Long>	Pipeline.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	Pipeline.zremrangeByRank(String key, long start, long stop)
Response<Long>	TransactionBase.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	TransactionBase.zremrangeByRank(String key, long start, long stop)
Response<Long>	MultiNodePipelineBase.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	MultiNodePipelineBase.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	MultiNodePipelineBase.zremrangeByScore(String key, double min, double max)
Response<Long>	MultiNodePipelineBase.zremrangeByScore(String key, String min, String max)
Response<Long>	Pipeline.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	Pipeline.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	Pipeline.zremrangeByScore(String key, double min, double max)
Response<Long>	Pipeline.zremrangeByScore(String key, String min, String max)
Response<Long>	TransactionBase.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	TransactionBase.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	TransactionBase.zremrangeByScore(String key, double min, double max)
Response<Long>	TransactionBase.zremrangeByScore(String key, String min, String max)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrange(byte[] key, long start, long stop)
Response<List<String>>	MultiNodePipelineBase.zrevrange(String key, long start, long stop)
Response<List<byte[]>>	Pipeline.zrevrange(byte[] key, long start, long stop)
Response<List<String>>	Pipeline.zrevrange(String key, long start, long stop)
Response<List<byte[]>>	TransactionBase.zrevrange(byte[] key, long start, long stop)
Response<List<String>>	TransactionBase.zrevrange(String key, long start, long stop)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByLex(String key, String max, String min)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	Pipeline.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	Pipeline.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<String>>	Pipeline.zrevrangeByLex(String key, String max, String min)
Response<List<String>>	Pipeline.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	TransactionBase.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<String>>	TransactionBase.zrevrangeByLex(String key, String max, String min)
Response<List<String>>	TransactionBase.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByScore(byte[] key, double max, double min)
Response<List<byte[]>>	MultiNodePipelineBase.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByScore(String key, double max, double min)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByScore(String key, String max, String min)
Response<List<String>>	MultiNodePipelineBase.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	Pipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	Pipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<byte[]>>	Pipeline.zrevrangeByScore(byte[] key, double max, double min)
Response<List<byte[]>>	Pipeline.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<List<String>>	Pipeline.zrevrangeByScore(String key, double max, double min)
Response<List<String>>	Pipeline.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<List<String>>	Pipeline.zrevrangeByScore(String key, String max, String min)
Response<List<String>>	Pipeline.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	TransactionBase.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<byte[]>>	TransactionBase.zrevrangeByScore(byte[] key, double max, double min)
Response<List<byte[]>>	TransactionBase.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<List<String>>	TransactionBase.zrevrangeByScore(String key, double max, double min)
Response<List<String>>	TransactionBase.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<List<String>>	TransactionBase.zrevrangeByScore(String key, String max, String min)
Response<List<String>>	TransactionBase.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(String key, double max, double min)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(String key, String max, String min)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(String key, double max, double min)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(String key, String max, String min)
Response<List<Tuple>>	Pipeline.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(String key, double max, double min)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(String key, String max, String min)
Response<List<Tuple>>	TransactionBase.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	MultiNodePipelineBase.zrevrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	Pipeline.zrevrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	Pipeline.zrevrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	TransactionBase.zrevrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	TransactionBase.zrevrangeWithScores(String key, long start, long stop)
Response<Long>	MultiNodePipelineBase.zrevrank(byte[] key, byte[] member)
Response<Long>	MultiNodePipelineBase.zrevrank(String key, String member)
Response<Long>	Pipeline.zrevrank(byte[] key, byte[] member)
Response<Long>	Pipeline.zrevrank(String key, String member)
Response<Long>	TransactionBase.zrevrank(byte[] key, byte[] member)
Response<Long>	TransactionBase.zrevrank(String key, String member)
Response<KeyValue<Long,Double>>	MultiNodePipelineBase.zrevrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	MultiNodePipelineBase.zrevrankWithScore(String key, String member)
Response<KeyValue<Long,Double>>	Pipeline.zrevrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	Pipeline.zrevrankWithScore(String key, String member)
Response<KeyValue<Long,Double>>	TransactionBase.zrevrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	TransactionBase.zrevrankWithScore(String key, String member)
Response<ScanResult<Tuple>>	MultiNodePipelineBase.zscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Tuple>>	MultiNodePipelineBase.zscan(String key, String cursor, ScanParams params)
Response<ScanResult<Tuple>>	Pipeline.zscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Tuple>>	Pipeline.zscan(String key, String cursor, ScanParams params)
Response<ScanResult<Tuple>>	TransactionBase.zscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Tuple>>	TransactionBase.zscan(String key, String cursor, ScanParams params)
Response<Double>	MultiNodePipelineBase.zscore(byte[] key, byte[] member)
Response<Double>	MultiNodePipelineBase.zscore(String key, String member)
Response<Double>	Pipeline.zscore(byte[] key, byte[] member)
Response<Double>	Pipeline.zscore(String key, String member)
Response<Double>	TransactionBase.zscore(byte[] key, byte[] member)
Response<Double>	TransactionBase.zscore(String key, String member)
Response<Set<byte[]>>	MultiNodePipelineBase.zunion(ZParams params, byte[]... keys)
Response<Set<String>>	MultiNodePipelineBase.zunion(ZParams params, String... keys)
Response<Set<byte[]>>	Pipeline.zunion(ZParams params, byte[]... keys)
Response<Set<String>>	Pipeline.zunion(ZParams params, String... keys)
Response<Set<byte[]>>	TransactionBase.zunion(ZParams params, byte[]... keys)
Response<Set<String>>	TransactionBase.zunion(ZParams params, String... keys)
Response<Long>	MultiNodePipelineBase.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiNodePipelineBase.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiNodePipelineBase.zunionstore(String dstKey, String... sets)
Response<Long>	MultiNodePipelineBase.zunionstore(String dstKey, ZParams params, String... sets)
Response<Long>	Pipeline.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	Pipeline.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	Pipeline.zunionstore(String dstKey, String... sets)
Response<Long>	Pipeline.zunionstore(String dstKey, ZParams params, String... sets)
Response<Long>	TransactionBase.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	TransactionBase.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	TransactionBase.zunionstore(String dstKey, String... sets)
Response<Long>	TransactionBase.zunionstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	MultiNodePipelineBase.zunionWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	MultiNodePipelineBase.zunionWithScores(ZParams params, String... keys)
Response<Set<Tuple>>	Pipeline.zunionWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	Pipeline.zunionWithScores(ZParams params, String... keys)
Response<Set<Tuple>>	TransactionBase.zunionWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	TransactionBase.zunionWithScores(ZParams params, String... keys)

Methods in redis.clients.jedis with parameters of type Response

Modifier and Type	Method	Description
void	Response.setDependency(Response<?> dependency)

Uses of Response in redis.clients.jedis.bloom.commands

Methods in redis.clients.jedis.bloom.commands that return Response

Modifier and Type	Method	Description
Response<Boolean>	BloomFilterPipelineCommands.bfAdd(String key, String item)
Response<Long>	BloomFilterPipelineCommands.bfCard(String key)
Response<Boolean>	BloomFilterPipelineCommands.bfExists(String key, String item)
Response<Map<String,Object>>	BloomFilterPipelineCommands.bfInfo(String key)
Response<List<Boolean>>	BloomFilterPipelineCommands.bfInsert(String key, String... items)
Response<List<Boolean>>	BloomFilterPipelineCommands.bfInsert(String key, BFInsertParams insertParams, String... items)
Response<String>	BloomFilterPipelineCommands.bfLoadChunk(String key, long iterator, byte[] data)
Response<List<Boolean>>	BloomFilterPipelineCommands.bfMAdd(String key, String... items)
Response<List<Boolean>>	BloomFilterPipelineCommands.bfMExists(String key, String... items)
Response<String>	BloomFilterPipelineCommands.bfReserve(String key, double errorRate, long capacity)
Response<String>	BloomFilterPipelineCommands.bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
Response<Map.Entry<Long,byte[]>>	BloomFilterPipelineCommands.bfScanDump(String key, long iterator)
Response<Boolean>	CuckooFilterPipelineCommands.cfAdd(String key, String item)
Response<Boolean>	CuckooFilterPipelineCommands.cfAddNx(String key, String item)
Response<Long>	CuckooFilterPipelineCommands.cfCount(String key, String item)
Response<Boolean>	CuckooFilterPipelineCommands.cfDel(String key, String item)
Response<Boolean>	CuckooFilterPipelineCommands.cfExists(String key, String item)
Response<Map<String,Object>>	CuckooFilterPipelineCommands.cfInfo(String key)
Response<List<Boolean>>	CuckooFilterPipelineCommands.cfInsert(String key, String... items)
Response<List<Boolean>>	CuckooFilterPipelineCommands.cfInsert(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	CuckooFilterPipelineCommands.cfInsertNx(String key, String... items)
Response<List<Boolean>>	CuckooFilterPipelineCommands.cfInsertNx(String key, CFInsertParams insertParams, String... items)
Response<String>	CuckooFilterPipelineCommands.cfLoadChunk(String key, long iterator, byte[] data)
Response<String>	CuckooFilterPipelineCommands.cfReserve(String key, long capacity)
Response<String>	CuckooFilterPipelineCommands.cfReserve(String key, long capacity, CFReserveParams reserveParams)
Response<Map.Entry<Long,byte[]>>	CuckooFilterPipelineCommands.cfScanDump(String key, long iterator)
Response<List<Long>>	CountMinSketchPipelineCommands.cmsIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	CountMinSketchPipelineCommands.cmsInfo(String key)
Response<String>	CountMinSketchPipelineCommands.cmsInitByDim(String key, long width, long depth)
Response<String>	CountMinSketchPipelineCommands.cmsInitByProb(String key, double error, double probability)
Response<String>	CountMinSketchPipelineCommands.cmsMerge(String destKey, String... keys)
Response<String>	CountMinSketchPipelineCommands.cmsMerge(String destKey, Map<String,Long> keysAndWeights)
Response<List<Long>>	CountMinSketchPipelineCommands.cmsQuery(String key, String... items)
Response<String>	TDigestSketchPipelineCommands.tdigestAdd(String key, double... values)
Response<List<Double>>	TDigestSketchPipelineCommands.tdigestByRank(String key, long... ranks)
Response<List<Double>>	TDigestSketchPipelineCommands.tdigestByRevRank(String key, long... ranks)
Response<List<Double>>	TDigestSketchPipelineCommands.tdigestCDF(String key, double... values)
Response<String>	TDigestSketchPipelineCommands.tdigestCreate(String key)
Response<String>	TDigestSketchPipelineCommands.tdigestCreate(String key, int compression)
Response<Map<String,Object>>	TDigestSketchPipelineCommands.tdigestInfo(String key)
Response<Double>	TDigestSketchPipelineCommands.tdigestMax(String key)
Response<String>	TDigestSketchPipelineCommands.tdigestMerge(String destinationKey, String... sourceKeys)
Response<String>	TDigestSketchPipelineCommands.tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys)
Response<Double>	TDigestSketchPipelineCommands.tdigestMin(String key)
Response<List<Double>>	TDigestSketchPipelineCommands.tdigestQuantile(String key, double... quantiles)
Response<List<Long>>	TDigestSketchPipelineCommands.tdigestRank(String key, double... values)
Response<String>	TDigestSketchPipelineCommands.tdigestReset(String key)
Response<List<Long>>	TDigestSketchPipelineCommands.tdigestRevRank(String key, double... values)
Response<Double>	TDigestSketchPipelineCommands.tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile)
Response<List<String>>	TopKFilterPipelineCommands.topkAdd(String key, String... items)
Response<List<Long>>	TopKFilterPipelineCommands.topkCount(String key, String... items)	Deprecated. As of RedisBloom 2.4, this command is regarded as deprecated.
Response<List<String>>	TopKFilterPipelineCommands.topkIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	TopKFilterPipelineCommands.topkInfo(String key)
Response<List<String>>	TopKFilterPipelineCommands.topkList(String key)
Response<Map<String,Long>>	TopKFilterPipelineCommands.topkListWithCount(String key)
Response<List<Boolean>>	TopKFilterPipelineCommands.topkQuery(String key, String... items)
Response<String>	TopKFilterPipelineCommands.topkReserve(String key, long topk)
Response<String>	TopKFilterPipelineCommands.topkReserve(String key, long topk, long width, long depth, double decay)

Uses of Response in redis.clients.jedis.commands

Methods in redis.clients.jedis.commands that return Response

Modifier and Type	Method	Description
Response<Long>	StringPipelineBinaryCommands.append(byte[] key, byte[] value)
Response<Long>	StringPipelineCommands.append(String key, String value)
Response<Long>	BitPipelineBinaryCommands.bitcount(byte[] key)
Response<Long>	BitPipelineBinaryCommands.bitcount(byte[] key, long start, long end)
Response<Long>	BitPipelineBinaryCommands.bitcount(byte[] key, long start, long end, BitCountOption option)
Response<Long>	BitPipelineCommands.bitcount(String key)
Response<Long>	BitPipelineCommands.bitcount(String key, long start, long end)
Response<Long>	BitPipelineCommands.bitcount(String key, long start, long end, BitCountOption option)
Response<List<Long>>	BitPipelineBinaryCommands.bitfield(byte[] key, byte[]... arguments)
Response<List<Long>>	BitPipelineCommands.bitfield(String key, String... arguments)
Response<List<Long>>	BitPipelineBinaryCommands.bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	BitPipelineCommands.bitfieldReadonly(String key, String... arguments)
Response<Long>	BitPipelineBinaryCommands.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	BitPipelineCommands.bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	BitPipelineBinaryCommands.bitpos(byte[] key, boolean value)
Response<Long>	BitPipelineBinaryCommands.bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	BitPipelineCommands.bitpos(String key, boolean value)
Response<Long>	BitPipelineCommands.bitpos(String key, boolean value, BitPosParams params)
Response<byte[]>	ListPipelineBinaryCommands.blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
Response<String>	ListPipelineCommands.blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
Response<KeyValue<byte[],List<byte[]>>>	ListPipelineBinaryCommands.blmpop(long timeout, ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	ListPipelineBinaryCommands.blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	ListPipelineCommands.blmpop(long timeout, ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	ListPipelineCommands.blmpop(long timeout, ListDirection direction, String... keys)
Response<List<byte[]>>	ListPipelineBinaryCommands.blpop(double timeout, byte[]... keys)
Response<List<byte[]>>	ListPipelineBinaryCommands.blpop(int timeout, byte[]... keys)
Response<KeyedListElement>	ListPipelineCommands.blpop(double timeout, String key)
Response<KeyedListElement>	ListPipelineCommands.blpop(double timeout, String... keys)
Response<List<String>>	ListPipelineCommands.blpop(int timeout, String key)
Response<List<String>>	ListPipelineCommands.blpop(int timeout, String... keys)
Response<List<byte[]>>	ListPipelineBinaryCommands.brpop(double timeout, byte[]... keys)
Response<List<byte[]>>	ListPipelineBinaryCommands.brpop(int timeout, byte[]... keys)
Response<KeyedListElement>	ListPipelineCommands.brpop(double timeout, String key)
Response<KeyedListElement>	ListPipelineCommands.brpop(double timeout, String... keys)
Response<List<String>>	ListPipelineCommands.brpop(int timeout, String key)
Response<List<String>>	ListPipelineCommands.brpop(int timeout, String... keys)
Response<byte[]>	ListPipelineBinaryCommands.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	ListPipelineCommands.brpoplpush(String source, String destination, int timeout)
Response<KeyValue<byte[],List<Tuple>>>	SortedSetPipelineBinaryCommands.bzmpop(long timeout, SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	SortedSetPipelineBinaryCommands.bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	SortedSetPipelineCommands.bzmpop(long timeout, SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	SortedSetPipelineCommands.bzmpop(long timeout, SortedSetOption option, String... keys)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.bzpopmax(double timeout, byte[]... keys)
Response<KeyedZSetElement>	SortedSetPipelineCommands.bzpopmax(double timeout, String... keys)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.bzpopmin(double timeout, byte[]... keys)
Response<KeyedZSetElement>	SortedSetPipelineCommands.bzpopmin(double timeout, String... keys)
Response<Boolean>	DatabasePipelineCommands.copy(byte[] srcKey, byte[] dstKey, int db, boolean replace)	Binary version of COPY.
Response<Boolean>	DatabasePipelineCommands.copy(String srcKey, String dstKey, int db, boolean replace)	Copy the value stored at the source key to the destination key.
Response<Boolean>	KeyPipelineBinaryCommands.copy(byte[] srcKey, byte[] dstKey, boolean replace)
Response<Boolean>	KeyPipelineCommands.copy(String srcKey, String dstKey, boolean replace)
Response<Long>	DatabasePipelineCommands.dbSize()	Return the number of keys in the currently-selected database.
Response<Long>	StringPipelineBinaryCommands.decr(byte[] key)
Response<Long>	StringPipelineCommands.decr(String key)
Response<Long>	StringPipelineBinaryCommands.decrBy(byte[] key, long decrement)
Response<Long>	StringPipelineCommands.decrBy(String key, long decrement)
Response<Long>	KeyPipelineBinaryCommands.del(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.del(byte[]... keys)
Response<Long>	KeyPipelineCommands.del(String key)
Response<Long>	KeyPipelineCommands.del(String... keys)
Response<byte[]>	KeyPipelineBinaryCommands.dump(byte[] key)
Response<byte[]>	KeyPipelineCommands.dump(String key)
Response<Object>	SampleBinaryKeyedPipelineCommands.eval(byte[] script, byte[] sampleKey)
Response<Object>	SampleKeyedPipelineCommands.eval(String script, String sampleKey)
Response<Object>	ScriptingKeyPipelineBinaryCommands.eval(byte[] script)
Response<Object>	ScriptingKeyPipelineBinaryCommands.eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	ScriptingKeyPipelineBinaryCommands.eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingKeyPipelineCommands.eval(String script)
Response<Object>	ScriptingKeyPipelineCommands.eval(String script, int keyCount, String... params)
Response<Object>	ScriptingKeyPipelineCommands.eval(String script, List<String> keys, List<String> args)
Response<Object>	ScriptingKeyPipelineBinaryCommands.evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingKeyPipelineCommands.evalReadonly(String script, List<String> keys, List<String> args)
Response<Object>	SampleBinaryKeyedPipelineCommands.evalsha(byte[] sha1, byte[] sampleKey)
Response<Object>	SampleKeyedPipelineCommands.evalsha(String sha1, String sampleKey)
Response<Object>	ScriptingKeyPipelineBinaryCommands.evalsha(byte[] sha1)
Response<Object>	ScriptingKeyPipelineBinaryCommands.evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	ScriptingKeyPipelineBinaryCommands.evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingKeyPipelineCommands.evalsha(String sha1)
Response<Object>	ScriptingKeyPipelineCommands.evalsha(String sha1, int keyCount, String... params)
Response<Object>	ScriptingKeyPipelineCommands.evalsha(String sha1, List<String> keys, List<String> args)
Response<Object>	ScriptingKeyPipelineBinaryCommands.evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	ScriptingKeyPipelineCommands.evalshaReadonly(String sha1, List<String> keys, List<String> args)
Response<Boolean>	KeyPipelineBinaryCommands.exists(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.exists(byte[]... keys)
Response<Boolean>	KeyPipelineCommands.exists(String key)
Response<Long>	KeyPipelineCommands.exists(String... keys)
Response<Long>	KeyPipelineBinaryCommands.expire(byte[] key, long seconds)
Response<Long>	KeyPipelineBinaryCommands.expire(byte[] key, long seconds, ExpiryOption expiryOption)
Response<Long>	KeyPipelineCommands.expire(String key, long seconds)
Response<Long>	KeyPipelineCommands.expire(String key, long seconds, ExpiryOption expiryOption)
Response<Long>	KeyPipelineBinaryCommands.expireAt(byte[] key, long unixTime)
Response<Long>	KeyPipelineBinaryCommands.expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
Response<Long>	KeyPipelineCommands.expireAt(String key, long unixTime)
Response<Long>	KeyPipelineCommands.expireAt(String key, long unixTime, ExpiryOption expiryOption)
Response<Long>	KeyPipelineBinaryCommands.expireTime(byte[] key)
Response<Long>	KeyPipelineCommands.expireTime(String key)
Response<Object>	FunctionPipelineBinaryCommands.fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	FunctionPipelineCommands.fcall(String name, List<String> keys, List<String> args)
Response<Object>	FunctionPipelineBinaryCommands.fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	FunctionPipelineCommands.fcallReadonly(String name, List<String> keys, List<String> args)
Response<String>	FunctionPipelineBinaryCommands.functionDelete(byte[] libraryName)
Response<String>	FunctionPipelineCommands.functionDelete(String libraryName)
Response<byte[]>	FunctionPipelineBinaryCommands.functionDump()
Response<byte[]>	FunctionPipelineCommands.functionDump()
Response<String>	FunctionPipelineBinaryCommands.functionFlush()
Response<String>	FunctionPipelineBinaryCommands.functionFlush(FlushMode mode)
Response<String>	FunctionPipelineCommands.functionFlush()
Response<String>	FunctionPipelineCommands.functionFlush(FlushMode mode)
Response<String>	FunctionPipelineBinaryCommands.functionKill()
Response<String>	FunctionPipelineCommands.functionKill()
Response<List<Object>>	FunctionPipelineBinaryCommands.functionList(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	FunctionPipelineCommands.functionList()
Response<List<LibraryInfo>>	FunctionPipelineCommands.functionList(String libraryNamePattern)
Response<List<Object>>	FunctionPipelineBinaryCommands.functionListBinary()
Response<List<Object>>	FunctionPipelineBinaryCommands.functionListWithCode(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	FunctionPipelineCommands.functionListWithCode()
Response<List<LibraryInfo>>	FunctionPipelineCommands.functionListWithCode(String libraryNamePattern)
Response<List<Object>>	FunctionPipelineBinaryCommands.functionListWithCodeBinary()
Response<String>	FunctionPipelineBinaryCommands.functionLoad(byte[] functionCode)
Response<String>	FunctionPipelineCommands.functionLoad(String functionCode)
Response<String>	FunctionPipelineBinaryCommands.functionLoadReplace(byte[] functionCode)
Response<String>	FunctionPipelineCommands.functionLoadReplace(String functionCode)
Response<String>	FunctionPipelineBinaryCommands.functionRestore(byte[] serializedValue)
Response<String>	FunctionPipelineBinaryCommands.functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<String>	FunctionPipelineCommands.functionRestore(byte[] serializedValue)
Response<String>	FunctionPipelineCommands.functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<FunctionStats>	FunctionPipelineCommands.functionStats()
Response<Object>	FunctionPipelineBinaryCommands.functionStatsBinary()
Response<Long>	GeoPipelineBinaryCommands.geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	GeoPipelineBinaryCommands.geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	GeoPipelineBinaryCommands.geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	GeoPipelineCommands.geoadd(String key, double longitude, double latitude, String member)
Response<Long>	GeoPipelineCommands.geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	GeoPipelineCommands.geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Double>	GeoPipelineBinaryCommands.geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	GeoPipelineBinaryCommands.geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	GeoPipelineCommands.geodist(String key, String member1, String member2)
Response<Double>	GeoPipelineCommands.geodist(String key, String member1, String member2, GeoUnit unit)
Response<List<byte[]>>	GeoPipelineBinaryCommands.geohash(byte[] key, byte[]... members)
Response<List<String>>	GeoPipelineCommands.geohash(String key, String... members)
Response<List<GeoCoordinate>>	GeoPipelineBinaryCommands.geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	GeoPipelineCommands.geopos(String key, String... members)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	GeoPipelineBinaryCommands.georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	GeoPipelineCommands.georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	GeoPipelineBinaryCommands.georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	GeoPipelineCommands.georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineBinaryCommands.geosearch(byte[] key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.geosearch(String key, String member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.geosearch(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	GeoPipelineCommands.geosearch(String key, GeoSearchParam params)
Response<Long>	GeoPipelineBinaryCommands.geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
Response<Long>	GeoPipelineBinaryCommands.geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
Response<Long>	GeoPipelineBinaryCommands.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	GeoPipelineBinaryCommands.geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	GeoPipelineBinaryCommands.geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	GeoPipelineCommands.geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
Response<Long>	GeoPipelineCommands.geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
Response<Long>	GeoPipelineCommands.geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	GeoPipelineCommands.geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	GeoPipelineCommands.geosearchStore(String dest, String src, GeoSearchParam params)
Response<Long>	GeoPipelineBinaryCommands.geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	GeoPipelineCommands.geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
Response<byte[]>	StringPipelineBinaryCommands.get(byte[] key)
Response<String>	StringPipelineCommands.get(String key)
Response<Boolean>	BitPipelineBinaryCommands.getbit(byte[] key, long offset)
Response<Boolean>	BitPipelineCommands.getbit(String key, long offset)
Response<byte[]>	StringPipelineBinaryCommands.getDel(byte[] key)
Response<String>	StringPipelineCommands.getDel(String key)
Response<byte[]>	StringPipelineBinaryCommands.getEx(byte[] key, GetExParams params)
Response<String>	StringPipelineCommands.getEx(String key, GetExParams params)
Response<byte[]>	StringPipelineBinaryCommands.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	StringPipelineCommands.getrange(String key, long startOffset, long endOffset)
Response<byte[]>	StringPipelineBinaryCommands.getSet(byte[] key, byte[] value)
Response<String>	StringPipelineCommands.getSet(String key, String value)
Response<Long>	HashPipelineBinaryCommands.hdel(byte[] key, byte[]... field)
Response<Long>	HashPipelineCommands.hdel(String key, String... field)
Response<Boolean>	HashPipelineBinaryCommands.hexists(byte[] key, byte[] field)
Response<Boolean>	HashPipelineCommands.hexists(String key, String field)
Response<byte[]>	HashPipelineBinaryCommands.hget(byte[] key, byte[] field)
Response<String>	HashPipelineCommands.hget(String key, String field)
Response<Map<byte[],byte[]>>	HashPipelineBinaryCommands.hgetAll(byte[] key)
Response<Map<String,String>>	HashPipelineCommands.hgetAll(String key)
Response<Long>	HashPipelineBinaryCommands.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	HashPipelineCommands.hincrBy(String key, String field, long value)
Response<Double>	HashPipelineBinaryCommands.hincrByFloat(byte[] key, byte[] field, double value)
Response<Double>	HashPipelineCommands.hincrByFloat(String key, String field, double value)
Response<Set<byte[]>>	HashPipelineBinaryCommands.hkeys(byte[] key)
Response<Set<String>>	HashPipelineCommands.hkeys(String key)
Response<Long>	HashPipelineBinaryCommands.hlen(byte[] key)
Response<Long>	HashPipelineCommands.hlen(String key)
Response<List<byte[]>>	HashPipelineBinaryCommands.hmget(byte[] key, byte[]... fields)
Response<List<String>>	HashPipelineCommands.hmget(String key, String... fields)
Response<String>	HashPipelineBinaryCommands.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	HashPipelineCommands.hmset(String key, Map<String,String> hash)
Response<byte[]>	HashPipelineBinaryCommands.hrandfield(byte[] key)
Response<List<byte[]>>	HashPipelineBinaryCommands.hrandfield(byte[] key, long count)
Response<String>	HashPipelineCommands.hrandfield(String key)
Response<List<String>>	HashPipelineCommands.hrandfield(String key, long count)
Response<Map<byte[],byte[]>>	HashPipelineBinaryCommands.hrandfieldWithValues(byte[] key, long count)
Response<Map<String,String>>	HashPipelineCommands.hrandfieldWithValues(String key, long count)
default Response<ScanResult<Map.Entry<byte[],byte[]>>>	HashPipelineBinaryCommands.hscan(byte[] key, byte[] cursor)
Response<ScanResult<Map.Entry<byte[],byte[]>>>	HashPipelineBinaryCommands.hscan(byte[] key, byte[] cursor, ScanParams params)
default Response<ScanResult<Map.Entry<String,String>>>	HashPipelineCommands.hscan(String key, String cursor)
Response<ScanResult<Map.Entry<String,String>>>	HashPipelineCommands.hscan(String key, String cursor, ScanParams params)
Response<Long>	HashPipelineBinaryCommands.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	HashPipelineBinaryCommands.hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	HashPipelineCommands.hset(String key, String field, String value)
Response<Long>	HashPipelineCommands.hset(String key, Map<String,String> hash)
Response<Long>	HashPipelineBinaryCommands.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	HashPipelineCommands.hsetnx(String key, String field, String value)
Response<Long>	HashPipelineBinaryCommands.hstrlen(byte[] key, byte[] field)
Response<Long>	HashPipelineCommands.hstrlen(String key, String field)
Response<List<byte[]>>	HashPipelineBinaryCommands.hvals(byte[] key)
Response<List<String>>	HashPipelineCommands.hvals(String key)
Response<Long>	StringPipelineBinaryCommands.incr(byte[] key)
Response<Long>	StringPipelineCommands.incr(String key)
Response<Long>	StringPipelineBinaryCommands.incrBy(byte[] key, long increment)
Response<Long>	StringPipelineCommands.incrBy(String key, long increment)
Response<Double>	StringPipelineBinaryCommands.incrByFloat(byte[] key, double increment)
Response<Double>	StringPipelineCommands.incrByFloat(String key, double increment)
Response<Set<byte[]>>	KeyPipelineBinaryCommands.keys(byte[] pattern)
Response<Set<String>>	KeyPipelineCommands.keys(String pattern)
Response<LCSMatchResult>	StringPipelineBinaryCommands.lcs(byte[] keyA, byte[] keyB, LCSParams params)
Response<LCSMatchResult>	StringPipelineCommands.lcs(String keyA, String keyB, LCSParams params)
Response<byte[]>	ListPipelineBinaryCommands.lindex(byte[] key, long index)
Response<String>	ListPipelineCommands.lindex(String key, long index)
Response<Long>	ListPipelineBinaryCommands.linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	ListPipelineCommands.linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	ListPipelineBinaryCommands.llen(byte[] key)
Response<Long>	ListPipelineCommands.llen(String key)
Response<byte[]>	ListPipelineBinaryCommands.lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to)
Response<String>	ListPipelineCommands.lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
Response<KeyValue<byte[],List<byte[]>>>	ListPipelineBinaryCommands.lmpop(ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	ListPipelineBinaryCommands.lmpop(ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	ListPipelineCommands.lmpop(ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	ListPipelineCommands.lmpop(ListDirection direction, String... keys)
Response<byte[]>	ListPipelineBinaryCommands.lpop(byte[] key)
Response<List<byte[]>>	ListPipelineBinaryCommands.lpop(byte[] key, int count)
Response<String>	ListPipelineCommands.lpop(String key)
Response<List<String>>	ListPipelineCommands.lpop(String key, int count)
Response<Long>	ListPipelineBinaryCommands.lpos(byte[] key, byte[] element)
Response<Long>	ListPipelineBinaryCommands.lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	ListPipelineBinaryCommands.lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	ListPipelineCommands.lpos(String key, String element)
Response<Long>	ListPipelineCommands.lpos(String key, String element, LPosParams params)
Response<List<Long>>	ListPipelineCommands.lpos(String key, String element, LPosParams params, long count)
Response<Long>	ListPipelineBinaryCommands.lpush(byte[] key, byte[]... args)
Response<Long>	ListPipelineCommands.lpush(String key, String... string)
Response<Long>	ListPipelineBinaryCommands.lpushx(byte[] key, byte[]... args)
Response<Long>	ListPipelineCommands.lpushx(String key, String... strings)
Response<List<byte[]>>	ListPipelineBinaryCommands.lrange(byte[] key, long start, long stop)
Response<List<String>>	ListPipelineCommands.lrange(String key, long start, long stop)
Response<Long>	ListPipelineBinaryCommands.lrem(byte[] key, long count, byte[] value)
Response<Long>	ListPipelineCommands.lrem(String key, long count, String value)
Response<String>	ListPipelineBinaryCommands.lset(byte[] key, long index, byte[] value)
Response<String>	ListPipelineCommands.lset(String key, long index, String value)
Response<String>	ListPipelineBinaryCommands.ltrim(byte[] key, long start, long stop)
Response<String>	ListPipelineCommands.ltrim(String key, long start, long stop)
Response<Long>	KeyPipelineBinaryCommands.memoryUsage(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.memoryUsage(byte[] key, int samples)
Response<Long>	KeyPipelineCommands.memoryUsage(String key)
Response<Long>	KeyPipelineCommands.memoryUsage(String key, int samples)
Response<List<byte[]>>	StringPipelineBinaryCommands.mget(byte[]... keys)
Response<List<String>>	StringPipelineCommands.mget(String... keys)
Response<String>	DatabasePipelineCommands.migrate(String host, int port, byte[] key, int destinationDB, int timeout)	Binary version of MIGRATE.
Response<String>	DatabasePipelineCommands.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, byte[]... keys)	Binary version of MIGRATE.
Response<String>	DatabasePipelineCommands.migrate(String host, int port, int destinationDB, int timeout, MigrateParams params, String... keys)	Migrate Command Atomically transfer a key from a source Redis instance to a destination Redis instance.
Response<String>	DatabasePipelineCommands.migrate(String host, int port, String key, int destinationDB, int timeout)	Migrate Command Atomically transfer a key from a source Redis instance to a destination Redis instance.
Response<String>	KeyPipelineBinaryCommands.migrate(String host, int port, byte[] key, int timeout)
Response<String>	KeyPipelineBinaryCommands.migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
Response<String>	KeyPipelineCommands.migrate(String host, int port, int timeout, MigrateParams params, String... keys)
Response<String>	KeyPipelineCommands.migrate(String host, int port, String key, int timeout)
Response<Long>	DatabasePipelineCommands.move(byte[] key, int dbIndex)	Binary version of MOVE.
Response<Long>	DatabasePipelineCommands.move(String key, int dbIndex)	Move the specified key from the currently selected DB to the specified destination DB.
Response<String>	StringPipelineBinaryCommands.mset(byte[]... keysvalues)
Response<String>	StringPipelineCommands.mset(String... keysvalues)
Response<Long>	StringPipelineBinaryCommands.msetnx(byte[]... keysvalues)
Response<Long>	StringPipelineCommands.msetnx(String... keysvalues)
Response<byte[]>	KeyPipelineBinaryCommands.objectEncoding(byte[] key)
Response<String>	KeyPipelineCommands.objectEncoding(String key)
Response<Long>	KeyPipelineBinaryCommands.objectFreq(byte[] key)
Response<Long>	KeyPipelineCommands.objectFreq(String key)
Response<Long>	KeyPipelineBinaryCommands.objectIdletime(byte[] key)
Response<Long>	KeyPipelineCommands.objectIdletime(String key)
Response<Long>	KeyPipelineBinaryCommands.objectRefcount(byte[] key)
Response<Long>	KeyPipelineCommands.objectRefcount(String key)
Response<Long>	KeyPipelineBinaryCommands.persist(byte[] key)
Response<Long>	KeyPipelineCommands.persist(String key)
Response<Long>	KeyPipelineBinaryCommands.pexpire(byte[] key, long milliseconds)
Response<Long>	KeyPipelineBinaryCommands.pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	KeyPipelineCommands.pexpire(String key, long milliseconds)
Response<Long>	KeyPipelineCommands.pexpire(String key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	KeyPipelineBinaryCommands.pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	KeyPipelineBinaryCommands.pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	KeyPipelineCommands.pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	KeyPipelineCommands.pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	KeyPipelineBinaryCommands.pexpireTime(byte[] key)
Response<Long>	KeyPipelineCommands.pexpireTime(String key)
Response<Long>	HyperLogLogPipelineBinaryCommands.pfadd(byte[] key, byte[]... elements)
Response<Long>	HyperLogLogPipelineCommands.pfadd(String key, String... elements)
Response<Long>	HyperLogLogPipelineBinaryCommands.pfcount(byte[] key)
Response<Long>	HyperLogLogPipelineBinaryCommands.pfcount(byte[]... keys)
Response<Long>	HyperLogLogPipelineCommands.pfcount(String key)
Response<Long>	HyperLogLogPipelineCommands.pfcount(String... keys)
Response<String>	HyperLogLogPipelineBinaryCommands.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	HyperLogLogPipelineCommands.pfmerge(String destkey, String... sourcekeys)
Response<String>	StringPipelineBinaryCommands.psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	StringPipelineCommands.psetex(String key, long milliseconds, String value)
Response<Long>	KeyPipelineBinaryCommands.pttl(byte[] key)
Response<Long>	KeyPipelineCommands.pttl(String key)
Response<byte[]>	KeyPipelineBinaryCommands.randomBinaryKey()
Response<String>	KeyPipelineCommands.randomKey()
Response<String>	KeyPipelineBinaryCommands.rename(byte[] oldkey, byte[] newkey)
Response<String>	KeyPipelineCommands.rename(String oldkey, String newkey)
Response<Long>	KeyPipelineBinaryCommands.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	KeyPipelineCommands.renamenx(String oldkey, String newkey)
Response<String>	KeyPipelineBinaryCommands.restore(byte[] key, long ttl, byte[] serializedValue)
Response<String>	KeyPipelineBinaryCommands.restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	KeyPipelineCommands.restore(String key, long ttl, byte[] serializedValue)
Response<String>	KeyPipelineCommands.restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
Response<byte[]>	ListPipelineBinaryCommands.rpop(byte[] key)
Response<List<byte[]>>	ListPipelineBinaryCommands.rpop(byte[] key, int count)
Response<String>	ListPipelineCommands.rpop(String key)
Response<List<String>>	ListPipelineCommands.rpop(String key, int count)
Response<byte[]>	ListPipelineBinaryCommands.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	ListPipelineCommands.rpoplpush(String srckey, String dstkey)
Response<Long>	ListPipelineBinaryCommands.rpush(byte[] key, byte[]... args)
Response<Long>	ListPipelineCommands.rpush(String key, String... string)
Response<Long>	ListPipelineBinaryCommands.rpushx(byte[] key, byte[]... args)
Response<Long>	ListPipelineCommands.rpushx(String key, String... strings)
Response<Long>	SetPipelineBinaryCommands.sadd(byte[] key, byte[]... members)
Response<Long>	SetPipelineCommands.sadd(String key, String... members)
Response<ScanResult<byte[]>>	KeyPipelineBinaryCommands.scan(byte[] cursor)
Response<ScanResult<byte[]>>	KeyPipelineBinaryCommands.scan(byte[] cursor, ScanParams params)
Response<ScanResult<byte[]>>	KeyPipelineBinaryCommands.scan(byte[] cursor, ScanParams params, byte[] type)
Response<ScanResult<String>>	KeyPipelineCommands.scan(String cursor)
Response<ScanResult<String>>	KeyPipelineCommands.scan(String cursor, ScanParams params)
Response<ScanResult<String>>	KeyPipelineCommands.scan(String cursor, ScanParams params, String type)
Response<Long>	SetPipelineBinaryCommands.scard(byte[] key)
Response<Long>	SetPipelineCommands.scard(String key)
Response<List<Boolean>>	SampleBinaryKeyedPipelineCommands.scriptExists(byte[] sampleKey, byte[]... sha1s)
Response<List<Boolean>>	SampleKeyedPipelineCommands.scriptExists(String sampleKey, String... sha1)
Response<String>	SampleBinaryKeyedPipelineCommands.scriptFlush(byte[] sampleKey)
Response<String>	SampleBinaryKeyedPipelineCommands.scriptFlush(byte[] sampleKey, FlushMode flushMode)
Response<String>	SampleKeyedPipelineCommands.scriptFlush(String sampleKey)
Response<String>	SampleKeyedPipelineCommands.scriptFlush(String sampleKey, FlushMode flushMode)
Response<String>	SampleBinaryKeyedPipelineCommands.scriptKill(byte[] sampleKey)
Response<String>	SampleKeyedPipelineCommands.scriptKill(String sampleKey)
Response<byte[]>	SampleBinaryKeyedPipelineCommands.scriptLoad(byte[] script, byte[] sampleKey)
Response<String>	SampleKeyedPipelineCommands.scriptLoad(String script, String sampleKey)
Response<Set<byte[]>>	SetPipelineBinaryCommands.sdiff(byte[]... keys)
Response<Set<String>>	SetPipelineCommands.sdiff(String... keys)
Response<Long>	SetPipelineBinaryCommands.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	SetPipelineCommands.sdiffstore(String dstKey, String... keys)
Response<String>	DatabasePipelineCommands.select(int index)	Select the DB with having the specified zero-based numeric index.
Response<String>	StringPipelineBinaryCommands.set(byte[] key, byte[] value)
Response<String>	StringPipelineBinaryCommands.set(byte[] key, byte[] value, SetParams params)
Response<String>	StringPipelineCommands.set(String key, String value)
Response<String>	StringPipelineCommands.set(String key, String value, SetParams params)
Response<Boolean>	BitPipelineBinaryCommands.setbit(byte[] key, long offset, boolean value)
Response<Boolean>	BitPipelineCommands.setbit(String key, long offset, boolean value)
Response<String>	StringPipelineBinaryCommands.setex(byte[] key, long seconds, byte[] value)
Response<String>	StringPipelineCommands.setex(String key, long seconds, String value)
Response<byte[]>	StringPipelineBinaryCommands.setGet(byte[] key, byte[] value, SetParams params)	WARNING: SetParams.get() MUST NOT be used with this method.
Response<String>	StringPipelineCommands.setGet(String key, String value, SetParams params)	WARNING: SetParams.get() MUST NOT be used with this method.
Response<Long>	StringPipelineBinaryCommands.setnx(byte[] key, byte[] value)
Response<Long>	StringPipelineCommands.setnx(String key, String value)
Response<Long>	StringPipelineBinaryCommands.setrange(byte[] key, long offset, byte[] value)
Response<Long>	StringPipelineCommands.setrange(String key, long offset, String value)
Response<Set<byte[]>>	SetPipelineBinaryCommands.sinter(byte[]... keys)
Response<Set<String>>	SetPipelineCommands.sinter(String... keys)
Response<Long>	SetPipelineBinaryCommands.sintercard(byte[]... keys)
Response<Long>	SetPipelineBinaryCommands.sintercard(int limit, byte[]... keys)
Response<Long>	SetPipelineCommands.sintercard(int limit, String... keys)
Response<Long>	SetPipelineCommands.sintercard(String... keys)
Response<Long>	SetPipelineBinaryCommands.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	SetPipelineCommands.sinterstore(String dstKey, String... keys)
Response<Boolean>	SetPipelineBinaryCommands.sismember(byte[] key, byte[] member)
Response<Boolean>	SetPipelineCommands.sismember(String key, String member)
Response<Set<byte[]>>	SetPipelineBinaryCommands.smembers(byte[] key)
Response<Set<String>>	SetPipelineCommands.smembers(String key)
Response<List<Boolean>>	SetPipelineBinaryCommands.smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	SetPipelineCommands.smismember(String key, String... members)
Response<Long>	SetPipelineBinaryCommands.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	SetPipelineCommands.smove(String srckey, String dstKey, String member)
Response<List<byte[]>>	KeyPipelineBinaryCommands.sort(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	KeyPipelineBinaryCommands.sort(byte[] key, SortingParams sortingParams)
Response<Long>	KeyPipelineBinaryCommands.sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
Response<List<String>>	KeyPipelineCommands.sort(String key)
Response<Long>	KeyPipelineCommands.sort(String key, String dstkey)
Response<List<String>>	KeyPipelineCommands.sort(String key, SortingParams sortingParams)
Response<Long>	KeyPipelineCommands.sort(String key, SortingParams sortingParams, String dstkey)
Response<List<byte[]>>	KeyPipelineBinaryCommands.sortReadonly(byte[] key, SortingParams sortingParams)
Response<List<String>>	KeyPipelineCommands.sortReadonly(String key, SortingParams sortingParams)
Response<byte[]>	SetPipelineBinaryCommands.spop(byte[] key)
Response<Set<byte[]>>	SetPipelineBinaryCommands.spop(byte[] key, long count)
Response<String>	SetPipelineCommands.spop(String key)
Response<Set<String>>	SetPipelineCommands.spop(String key, long count)
Response<byte[]>	SetPipelineBinaryCommands.srandmember(byte[] key)
Response<List<byte[]>>	SetPipelineBinaryCommands.srandmember(byte[] key, int count)
Response<String>	SetPipelineCommands.srandmember(String key)
Response<List<String>>	SetPipelineCommands.srandmember(String key, int count)
Response<Long>	SetPipelineBinaryCommands.srem(byte[] key, byte[]... members)
Response<Long>	SetPipelineCommands.srem(String key, String... members)
default Response<ScanResult<byte[]>>	SetPipelineBinaryCommands.sscan(byte[] key, byte[] cursor)
Response<ScanResult<byte[]>>	SetPipelineBinaryCommands.sscan(byte[] key, byte[] cursor, ScanParams params)
default Response<ScanResult<String>>	SetPipelineCommands.sscan(String key, String cursor)
Response<ScanResult<String>>	SetPipelineCommands.sscan(String key, String cursor, ScanParams params)
Response<LCSMatchResult>	StringPipelineBinaryCommands.strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)	Deprecated. STRALGO LCS command will be removed from Redis 7.
Response<LCSMatchResult>	StringPipelineCommands.strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)	Deprecated. STRALGO LCS command will be removed from Redis 7.
Response<Long>	StringPipelineBinaryCommands.strlen(byte[] key)
Response<Long>	StringPipelineCommands.strlen(String key)
Response<byte[]>	StringPipelineBinaryCommands.substr(byte[] key, int start, int end)
Response<String>	StringPipelineCommands.substr(String key, int start, int end)
Response<Set<byte[]>>	SetPipelineBinaryCommands.sunion(byte[]... keys)
Response<Set<String>>	SetPipelineCommands.sunion(String... keys)
Response<Long>	SetPipelineBinaryCommands.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	SetPipelineCommands.sunionstore(String dstKey, String... keys)
Response<String>	DatabasePipelineCommands.swapDB(int index1, int index2)	This command swaps two Redis databases, so that immediately all the clients connected to a given database will see the data of the other database, and the other way around.
Response<Long>	KeyPipelineBinaryCommands.touch(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.touch(byte[]... keys)
Response<Long>	KeyPipelineCommands.touch(String key)
Response<Long>	KeyPipelineCommands.touch(String... keys)
Response<Long>	KeyPipelineBinaryCommands.ttl(byte[] key)
Response<Long>	KeyPipelineCommands.ttl(String key)
Response<String>	KeyPipelineBinaryCommands.type(byte[] key)
Response<String>	KeyPipelineCommands.type(String key)
Response<Long>	KeyPipelineBinaryCommands.unlink(byte[] key)
Response<Long>	KeyPipelineBinaryCommands.unlink(byte[]... keys)
Response<Long>	KeyPipelineCommands.unlink(String key)
Response<Long>	KeyPipelineCommands.unlink(String... keys)
Response<KeyValue<Long,Long>>	SampleBinaryKeyedPipelineCommands.waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout)
Response<KeyValue<Long,Long>>	SampleKeyedPipelineCommands.waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout)
Response<Long>	SampleBinaryKeyedPipelineCommands.waitReplicas(byte[] sampleKey, int replicas, long timeout)
Response<Long>	SampleKeyedPipelineCommands.waitReplicas(String sampleKey, int replicas, long timeout)
Response<Long>	StreamPipelineBinaryCommands.xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	StreamPipelineCommands.xack(String key, String group, StreamEntryID... ids)	XACK key group ID [ID ...]
default Response<byte[]>	StreamPipelineBinaryCommands.xadd(byte[] key, Map<byte[],byte[]> hash, XAddParams params)
Response<byte[]>	StreamPipelineBinaryCommands.xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
default Response<StreamEntryID>	StreamPipelineCommands.xadd(String key, Map<String,String> hash, XAddParams params)	XADD key [NOMKSTREAM] [MAXLEN|MINID [=|~] threshold [LIMIT count]] *|ID field value [field value ...]
Response<StreamEntryID>	StreamPipelineCommands.xadd(String key, XAddParams params, Map<String,String> hash)
Response<StreamEntryID>	StreamPipelineCommands.xadd(String key, StreamEntryID id, Map<String,String> hash)	XADD key ID field string [field string ...]
Response<List<Object>>	StreamPipelineBinaryCommands.xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntry>>>	StreamPipelineCommands.xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)	XAUTOCLAIM key group consumer min-idle-time start [COUNT count]
Response<List<Object>>	StreamPipelineBinaryCommands.xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntryID>>>	StreamPipelineCommands.xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)	XAUTOCLAIM key group consumer min-idle-time start [COUNT count] JUSTID
Response<List<byte[]>>	StreamPipelineBinaryCommands.xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntry>>	StreamPipelineCommands.xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)	XCLAIM key group consumer min-idle-time <ID-1> ... <ID-N> [IDLE <milliseconds>] [TIME <mstime>] [RETRYCOUNT <count>] [FORCE]
Response<List<byte[]>>	StreamPipelineBinaryCommands.xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntryID>>	StreamPipelineCommands.xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)	XCLAIM key group consumer min-idle-time <ID-1> ... <ID-N> [IDLE <milliseconds>] [TIME <mstime>] [RETRYCOUNT <count>] [FORCE] JUSTID
Response<Long>	StreamPipelineBinaryCommands.xdel(byte[] key, byte[]... ids)
Response<Long>	StreamPipelineCommands.xdel(String key, StreamEntryID... ids)	XDEL key ID [ID ...]
Response<String>	StreamPipelineBinaryCommands.xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
Response<String>	StreamPipelineCommands.xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)	XGROUP CREATE key groupName <id or $>
Response<Boolean>	StreamPipelineBinaryCommands.xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Boolean>	StreamPipelineCommands.xgroupCreateConsumer(String key, String groupName, String consumerName)	XGROUP CREATECONSUMER key groupName consumerName
Response<Long>	StreamPipelineBinaryCommands.xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Long>	StreamPipelineCommands.xgroupDelConsumer(String key, String groupName, String consumerName)	XGROUP DELCONSUMER key groupName consumerName
Response<Long>	StreamPipelineBinaryCommands.xgroupDestroy(byte[] key, byte[] groupName)
Response<Long>	StreamPipelineCommands.xgroupDestroy(String key, String groupName)	XGROUP DESTROY key groupName
Response<String>	StreamPipelineBinaryCommands.xgroupSetID(byte[] key, byte[] groupName, byte[] id)
Response<String>	StreamPipelineCommands.xgroupSetID(String key, String groupName, StreamEntryID id)	XGROUP SETID key groupName <id or $>
Response<List<Object>>	StreamPipelineBinaryCommands.xinfoConsumers(byte[] key, byte[] group)
Response<List<StreamConsumersInfo>>	StreamPipelineCommands.xinfoConsumers(String key, String group)	Introspection command used in order to retrieve different information about consumers in the group
Response<List<Object>>	StreamPipelineBinaryCommands.xinfoGroup(byte[] key)	Deprecated. Use StreamPipelineBinaryCommands.xinfoGroups(byte[]).
Response<List<StreamGroupInfo>>	StreamPipelineCommands.xinfoGroup(String key)	Deprecated. Use StreamPipelineCommands.xinfoGroups(java.lang.String).
Response<List<Object>>	StreamPipelineBinaryCommands.xinfoGroups(byte[] key)
Response<List<StreamGroupInfo>>	StreamPipelineCommands.xinfoGroups(String key)	Introspection command used in order to retrieve different information about groups in the stream
Response<Object>	StreamPipelineBinaryCommands.xinfoStream(byte[] key)
Response<StreamInfo>	StreamPipelineCommands.xinfoStream(String key)	Introspection command used in order to retrieve different information about the stream
Response<Object>	StreamPipelineBinaryCommands.xinfoStreamFull(byte[] key)	Introspection command used in order to retrieve all information about the stream
Response<Object>	StreamPipelineBinaryCommands.xinfoStreamFull(byte[] key, int count)	Introspection command used in order to retrieve all information about the stream
Response<StreamFullInfo>	StreamPipelineCommands.xinfoStreamFull(String key)	Introspection command used in order to retrieve all information about the stream
Response<StreamFullInfo>	StreamPipelineCommands.xinfoStreamFull(String key, int count)	Introspection command used in order to retrieve all information about the stream
Response<Long>	StreamPipelineBinaryCommands.xlen(byte[] key)
Response<Long>	StreamPipelineCommands.xlen(String key)	XLEN key
Response<Object>	StreamPipelineBinaryCommands.xpending(byte[] key, byte[] groupName)
Response<List<Object>>	StreamPipelineBinaryCommands.xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)	Deprecated. Use StreamPipelineBinaryCommands.xpending(byte[], byte[], redis.clients.jedis.params.XPendingParams).
Response<List<Object>>	StreamPipelineBinaryCommands.xpending(byte[] key, byte[] groupName, XPendingParams params)
Response<StreamPendingSummary>	StreamPipelineCommands.xpending(String key, String groupName)	XPENDING key group
Response<List<StreamPendingEntry>>	StreamPipelineCommands.xpending(String key, String groupName, XPendingParams params)	XPENDING key group [[IDLE min-idle-time] start end count [consumer]]
Response<List<StreamPendingEntry>>	StreamPipelineCommands.xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)	Deprecated. Use StreamPipelineCommands.xpending(java.lang.String, java.lang.String, redis.clients.jedis.params.XPendingParams).
Response<List<Object>>	StreamPipelineBinaryCommands.xrange(byte[] key, byte[] start, byte[] end)
Response<List<Object>>	StreamPipelineBinaryCommands.xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	StreamPipelineCommands.xrange(String key, String start, String end)
Response<List<StreamEntry>>	StreamPipelineCommands.xrange(String key, String start, String end, int count)
Response<List<StreamEntry>>	StreamPipelineCommands.xrange(String key, StreamEntryID start, StreamEntryID end)	XRANGE key start end
Response<List<StreamEntry>>	StreamPipelineCommands.xrange(String key, StreamEntryID start, StreamEntryID end, int count)	XRANGE key start end COUNT count
Response<List<Object>>	StreamPipelineBinaryCommands.xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	StreamPipelineCommands.xread(XReadParams xReadParams, Map<String,StreamEntryID> streams)	XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
Response<List<Object>>	StreamPipelineBinaryCommands.xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	StreamPipelineCommands.xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)	XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
Response<List<Object>>	StreamPipelineBinaryCommands.xrevrange(byte[] key, byte[] end, byte[] start)
Response<List<Object>>	StreamPipelineBinaryCommands.xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	StreamPipelineCommands.xrevrange(String key, String end, String start)
Response<List<StreamEntry>>	StreamPipelineCommands.xrevrange(String key, String end, String start, int count)
Response<List<StreamEntry>>	StreamPipelineCommands.xrevrange(String key, StreamEntryID end, StreamEntryID start)	XREVRANGE key end start
Response<List<StreamEntry>>	StreamPipelineCommands.xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)	XREVRANGE key end start COUNT count
Response<Long>	StreamPipelineBinaryCommands.xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	StreamPipelineBinaryCommands.xtrim(byte[] key, XTrimParams params)
Response<Long>	StreamPipelineCommands.xtrim(String key, long maxLen, boolean approximate)	XTRIM key MAXLEN [~] count
Response<Long>	StreamPipelineCommands.xtrim(String key, XTrimParams params)	XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]
Response<Long>	SortedSetPipelineBinaryCommands.zadd(byte[] key, double score, byte[] member)
Response<Long>	SortedSetPipelineBinaryCommands.zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	SortedSetPipelineBinaryCommands.zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	SortedSetPipelineBinaryCommands.zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	SortedSetPipelineCommands.zadd(String key, double score, String member)
Response<Long>	SortedSetPipelineCommands.zadd(String key, double score, String member, ZAddParams params)
Response<Long>	SortedSetPipelineCommands.zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	SortedSetPipelineCommands.zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Double>	SortedSetPipelineBinaryCommands.zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
Response<Double>	SortedSetPipelineCommands.zaddIncr(String key, double score, String member, ZAddParams params)
Response<Long>	SortedSetPipelineBinaryCommands.zcard(byte[] key)
Response<Long>	SortedSetPipelineCommands.zcard(String key)
Response<Long>	SortedSetPipelineBinaryCommands.zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	SortedSetPipelineBinaryCommands.zcount(byte[] key, double min, double max)
Response<Long>	SortedSetPipelineCommands.zcount(String key, double min, double max)
Response<Long>	SortedSetPipelineCommands.zcount(String key, String min, String max)
Response<Set<byte[]>>	SortedSetPipelineBinaryCommands.zdiff(byte[]... keys)
Response<Set<String>>	SortedSetPipelineCommands.zdiff(String... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zdiffStore(byte[] dstkey, byte[]... keys)
Response<Long>	SortedSetPipelineCommands.zdiffStore(String dstKey, String... keys)
Response<Set<Tuple>>	SortedSetPipelineBinaryCommands.zdiffWithScores(byte[]... keys)
Response<Set<Tuple>>	SortedSetPipelineCommands.zdiffWithScores(String... keys)
Response<Double>	SortedSetPipelineBinaryCommands.zincrby(byte[] key, double increment, byte[] member)
Response<Double>	SortedSetPipelineBinaryCommands.zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	SortedSetPipelineCommands.zincrby(String key, double increment, String member)
Response<Double>	SortedSetPipelineCommands.zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Set<byte[]>>	SortedSetPipelineBinaryCommands.zinter(ZParams params, byte[]... keys)
Response<Set<String>>	SortedSetPipelineCommands.zinter(ZParams params, String... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zintercard(byte[]... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zintercard(long limit, byte[]... keys)
Response<Long>	SortedSetPipelineCommands.zintercard(long limit, String... keys)
Response<Long>	SortedSetPipelineCommands.zintercard(String... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	SortedSetPipelineBinaryCommands.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	SortedSetPipelineCommands.zinterstore(String dstKey, String... sets)
Response<Long>	SortedSetPipelineCommands.zinterstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	SortedSetPipelineBinaryCommands.zinterWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	SortedSetPipelineCommands.zinterWithScores(ZParams params, String... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	SortedSetPipelineCommands.zlexcount(String key, String min, String max)
Response<KeyValue<byte[],List<Tuple>>>	SortedSetPipelineBinaryCommands.zmpop(SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	SortedSetPipelineBinaryCommands.zmpop(SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	SortedSetPipelineCommands.zmpop(SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	SortedSetPipelineCommands.zmpop(SortedSetOption option, String... keys)
Response<List<Double>>	SortedSetPipelineBinaryCommands.zmscore(byte[] key, byte[]... members)
Response<List<Double>>	SortedSetPipelineCommands.zmscore(String key, String... members)
Response<Tuple>	SortedSetPipelineBinaryCommands.zpopmax(byte[] key)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zpopmax(byte[] key, int count)
Response<Tuple>	SortedSetPipelineCommands.zpopmax(String key)
Response<List<Tuple>>	SortedSetPipelineCommands.zpopmax(String key, int count)
Response<Tuple>	SortedSetPipelineBinaryCommands.zpopmin(byte[] key)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zpopmin(byte[] key, int count)
Response<Tuple>	SortedSetPipelineCommands.zpopmin(String key)
Response<List<Tuple>>	SortedSetPipelineCommands.zpopmin(String key, int count)
Response<byte[]>	SortedSetPipelineBinaryCommands.zrandmember(byte[] key)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrandmember(byte[] key, long count)
Response<String>	SortedSetPipelineCommands.zrandmember(String key)
Response<List<String>>	SortedSetPipelineCommands.zrandmember(String key, long count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrandmemberWithScores(byte[] key, long count)
Response<List<Tuple>>	SortedSetPipelineCommands.zrandmemberWithScores(String key, long count)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrange(byte[] key, long start, long stop)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrange(byte[] key, ZRangeParams zRangeParams)
Response<List<String>>	SortedSetPipelineCommands.zrange(String key, long start, long stop)
Response<List<String>>	SortedSetPipelineCommands.zrange(String key, ZRangeParams zRangeParams)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrangeByLex(String key, String min, String max)
Response<List<String>>	SortedSetPipelineCommands.zrangeByLex(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByScore(byte[] key, double min, double max)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrangeByScore(String key, double min, double max)
Response<List<String>>	SortedSetPipelineCommands.zrangeByScore(String key, double min, double max, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrangeByScore(String key, String min, String max)
Response<List<String>>	SortedSetPipelineCommands.zrangeByScore(String key, String min, String max, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeByScoreWithScores(String key, double min, double max)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeByScoreWithScores(String key, String min, String max)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Long>	SortedSetPipelineBinaryCommands.zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
Response<Long>	SortedSetPipelineCommands.zrangestore(String dest, String src, ZRangeParams zRangeParams)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	SortedSetPipelineCommands.zrangeWithScores(String key, ZRangeParams zRangeParams)
Response<Long>	SortedSetPipelineBinaryCommands.zrank(byte[] key, byte[] member)
Response<Long>	SortedSetPipelineCommands.zrank(String key, String member)
Response<KeyValue<Long,Double>>	SortedSetPipelineBinaryCommands.zrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	SortedSetPipelineCommands.zrankWithScore(String key, String member)
Response<Long>	SortedSetPipelineBinaryCommands.zrem(byte[] key, byte[]... members)
Response<Long>	SortedSetPipelineCommands.zrem(String key, String... members)
Response<Long>	SortedSetPipelineBinaryCommands.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	SortedSetPipelineCommands.zremrangeByLex(String key, String min, String max)
Response<Long>	SortedSetPipelineBinaryCommands.zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	SortedSetPipelineCommands.zremrangeByRank(String key, long start, long stop)
Response<Long>	SortedSetPipelineBinaryCommands.zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	SortedSetPipelineBinaryCommands.zremrangeByScore(byte[] key, double min, double max)
Response<Long>	SortedSetPipelineCommands.zremrangeByScore(String key, double min, double max)
Response<Long>	SortedSetPipelineCommands.zremrangeByScore(String key, String min, String max)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrange(byte[] key, long start, long stop)
Response<List<String>>	SortedSetPipelineCommands.zrevrange(String key, long start, long stop)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByLex(String key, String max, String min)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByScore(byte[] key, double max, double min)
Response<List<byte[]>>	SortedSetPipelineBinaryCommands.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByScore(String key, double max, double min)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByScore(String key, String max, String min)
Response<List<String>>	SortedSetPipelineCommands.zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineCommands.zrevrangeByScoreWithScores(String key, double max, double min)
Response<List<Tuple>>	SortedSetPipelineCommands.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineCommands.zrevrangeByScoreWithScores(String key, String max, String min)
Response<List<Tuple>>	SortedSetPipelineCommands.zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	SortedSetPipelineBinaryCommands.zrevrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	SortedSetPipelineCommands.zrevrangeWithScores(String key, long start, long stop)
Response<Long>	SortedSetPipelineBinaryCommands.zrevrank(byte[] key, byte[] member)
Response<Long>	SortedSetPipelineCommands.zrevrank(String key, String member)
Response<KeyValue<Long,Double>>	SortedSetPipelineBinaryCommands.zrevrankWithScore(byte[] key, byte[] member)
Response<KeyValue<Long,Double>>	SortedSetPipelineCommands.zrevrankWithScore(String key, String member)
default Response<ScanResult<Tuple>>	SortedSetPipelineBinaryCommands.zscan(byte[] key, byte[] cursor)
Response<ScanResult<Tuple>>	SortedSetPipelineBinaryCommands.zscan(byte[] key, byte[] cursor, ScanParams params)
default Response<ScanResult<Tuple>>	SortedSetPipelineCommands.zscan(String key, String cursor)
Response<ScanResult<Tuple>>	SortedSetPipelineCommands.zscan(String key, String cursor, ScanParams params)
Response<Double>	SortedSetPipelineBinaryCommands.zscore(byte[] key, byte[] member)
Response<Double>	SortedSetPipelineCommands.zscore(String key, String member)
Response<Set<byte[]>>	SortedSetPipelineBinaryCommands.zunion(ZParams params, byte[]... keys)
Response<Set<String>>	SortedSetPipelineCommands.zunion(ZParams params, String... keys)
Response<Long>	SortedSetPipelineBinaryCommands.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	SortedSetPipelineBinaryCommands.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	SortedSetPipelineCommands.zunionstore(String dstKey, String... sets)
Response<Long>	SortedSetPipelineCommands.zunionstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	SortedSetPipelineBinaryCommands.zunionWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	SortedSetPipelineCommands.zunionWithScores(ZParams params, String... keys)

Uses of Response in redis.clients.jedis.graph

Methods in redis.clients.jedis.graph that return Response

Modifier and Type	Method	Description
Response<String>	RedisGraphPipelineCommands.graphDelete(String name)
Response<List<String>>	RedisGraphPipelineCommands.graphProfile(String graphName, String query)
Response<ResultSet>	RedisGraphPipelineCommands.graphQuery(String name, String query)
Response<ResultSet>	RedisGraphPipelineCommands.graphQuery(String name, String query, long timeout)
Response<ResultSet>	RedisGraphPipelineCommands.graphQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	RedisGraphPipelineCommands.graphQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	RedisGraphPipelineCommands.graphReadonlyQuery(String name, String query)
Response<ResultSet>	RedisGraphPipelineCommands.graphReadonlyQuery(String name, String query, long timeout)
Response<ResultSet>	RedisGraphPipelineCommands.graphReadonlyQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	RedisGraphPipelineCommands.graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)

Uses of Response in redis.clients.jedis.json

Methods in redis.clients.jedis.json that return Response

Modifier and Type	Method	Description
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrAppend(String key, Path2 path, Object... objects)
Response<Long>	RedisJsonPipelineCommands.jsonArrAppend(String key, Path path, Object... pojos)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrIndex(String key, Path2 path, Object scalar)
Response<Long>	RedisJsonPipelineCommands.jsonArrIndex(String key, Path path, Object scalar)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrInsert(String key, Path2 path, int index, Object... objects)
Response<Long>	RedisJsonPipelineCommands.jsonArrInsert(String key, Path path, int index, Object... pojos)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
Response<Long>	RedisJsonPipelineCommands.jsonArrLen(String key)
Response<Long>	RedisJsonPipelineCommands.jsonArrLen(String key, Path path)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrLen(String key, Path2 path)
Response<Object>	RedisJsonPipelineCommands.jsonArrPop(String key)
<T> Response<T>	RedisJsonPipelineCommands.jsonArrPop(String key, Class<T> clazz)
<T> Response<T>	RedisJsonPipelineCommands.jsonArrPop(String key, Class<T> clazz, Path path)
<T> Response<T>	RedisJsonPipelineCommands.jsonArrPop(String key, Class<T> clazz, Path path, int index)
Response<Object>	RedisJsonPipelineCommands.jsonArrPop(String key, Path path)
Response<List<Object>>	RedisJsonPipelineCommands.jsonArrPop(String key, Path2 path)
Response<List<Object>>	RedisJsonPipelineCommands.jsonArrPop(String key, Path2 path, int index)
Response<Object>	RedisJsonPipelineCommands.jsonArrPop(String key, Path path, int index)
Response<List<Long>>	RedisJsonPipelineCommands.jsonArrTrim(String key, Path2 path, int start, int stop)
Response<Long>	RedisJsonPipelineCommands.jsonArrTrim(String key, Path path, int start, int stop)
Response<Long>	RedisJsonPipelineCommands.jsonClear(String key)
Response<Long>	RedisJsonPipelineCommands.jsonClear(String key, Path path)
Response<Long>	RedisJsonPipelineCommands.jsonClear(String key, Path2 path)
Response<Long>	RedisJsonPipelineCommands.jsonDel(String key)
Response<Long>	RedisJsonPipelineCommands.jsonDel(String key, Path path)
Response<Long>	RedisJsonPipelineCommands.jsonDel(String key, Path2 path)
Response<Object>	RedisJsonPipelineCommands.jsonGet(String key)
<T> Response<T>	RedisJsonPipelineCommands.jsonGet(String key, Class<T> clazz)
<T> Response<T>	RedisJsonPipelineCommands.jsonGet(String key, Class<T> clazz, Path... paths)
Response<Object>	RedisJsonPipelineCommands.jsonGet(String key, Path... paths)
Response<Object>	RedisJsonPipelineCommands.jsonGet(String key, Path2... paths)
default <T> Response<List<T>>	RedisJsonPipelineCommands.jsonMGet(Class<T> clazz, String... keys)
default Response<List<org.json.JSONArray>>	RedisJsonPipelineCommands.jsonMGet(String... keys)
Response<List<org.json.JSONArray>>	RedisJsonPipelineCommands.jsonMGet(Path2 path, String... keys)
<T> Response<List<T>>	RedisJsonPipelineCommands.jsonMGet(Path path, Class<T> clazz, String... keys)
Response<org.json.JSONArray>	RedisJsonPipelineCommands.jsonNumIncrBy(String key, Path2 path, double value)
Response<Double>	RedisJsonPipelineCommands.jsonNumIncrBy(String key, Path path, double value)
default Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Object object)
default Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Object object, JsonSetParams params)
Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Path2 path, Object object)
Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Path path, Object pojo)
Response<String>	RedisJsonPipelineCommands.jsonSet(String key, Path path, Object pojo, JsonSetParams params)
default Response<String>	RedisJsonPipelineCommands.jsonSetLegacy(String key, Object pojo)
default Response<String>	RedisJsonPipelineCommands.jsonSetLegacy(String key, Object pojo, JsonSetParams params)
default Response<String>	RedisJsonPipelineCommands.jsonSetWithEscape(String key, Object object)
default Response<String>	RedisJsonPipelineCommands.jsonSetWithEscape(String key, Object object, JsonSetParams params)
Response<String>	RedisJsonPipelineCommands.jsonSetWithEscape(String key, Path2 path, Object object)
Response<String>	RedisJsonPipelineCommands.jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params)
Response<Long>	RedisJsonPipelineCommands.jsonStrAppend(String key, Object string)
Response<List<Long>>	RedisJsonPipelineCommands.jsonStrAppend(String key, Path2 path, Object string)
Response<Long>	RedisJsonPipelineCommands.jsonStrAppend(String key, Path path, Object string)
Response<Long>	RedisJsonPipelineCommands.jsonStrLen(String key)
Response<Long>	RedisJsonPipelineCommands.jsonStrLen(String key, Path path)
Response<List<Long>>	RedisJsonPipelineCommands.jsonStrLen(String key, Path2 path)
Response<String>	RedisJsonPipelineCommands.jsonToggle(String key, Path path)
Response<List<Boolean>>	RedisJsonPipelineCommands.jsonToggle(String key, Path2 path)
Response<Class<?>>	RedisJsonPipelineCommands.jsonType(String key)
Response<Class<?>>	RedisJsonPipelineCommands.jsonType(String key, Path path)
Response<List<Class<?>>>	RedisJsonPipelineCommands.jsonType(String key, Path2 path)

Uses of Response in redis.clients.jedis.search

Methods in redis.clients.jedis.search that return Response

Modifier and Type	Method	Description
Response<AggregationResult>	RediSearchPipelineCommands.ftAggregate(String indexName, AggregationBuilder aggr)
Response<String>	RediSearchPipelineCommands.ftAliasAdd(String aliasName, String indexName)	Deprecated.
Response<String>	RediSearchPipelineCommands.ftAliasDel(String aliasName)	Deprecated.
Response<String>	RediSearchPipelineCommands.ftAliasUpdate(String aliasName, String indexName)	Deprecated.
Response<String>	RediSearchPipelineCommands.ftAlter(String indexName, Iterable<SchemaField> schemaFields)
Response<String>	RediSearchPipelineCommands.ftAlter(String indexName, Schema schema)
default Response<String>	RediSearchPipelineCommands.ftAlter(String indexName, Schema.Field... fields)
default Response<String>	RediSearchPipelineCommands.ftAlter(String indexName, SchemaField... schemaFields)
Response<Map<String,String>>	RediSearchPipelineCommands.ftConfigGet(String option)
Response<Map<String,String>>	RediSearchPipelineCommands.ftConfigGet(String indexName, String option)
Response<String>	RediSearchPipelineCommands.ftConfigSet(String option, String value)
Response<String>	RediSearchPipelineCommands.ftConfigSet(String indexName, String option, String value)
default Response<String>	RediSearchPipelineCommands.ftCreate(String indexName, Iterable<SchemaField> schemaFields)
Response<String>	RediSearchPipelineCommands.ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields)
default Response<String>	RediSearchPipelineCommands.ftCreate(String indexName, FTCreateParams createParams, SchemaField... schemaFields)
Response<String>	RediSearchPipelineCommands.ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
default Response<String>	RediSearchPipelineCommands.ftCreate(String indexName, SchemaField... schemaFields)
Response<String>	RediSearchPipelineCommands.ftCursorDel(String indexName, long cursorId)	Deprecated.
Response<AggregationResult>	RediSearchPipelineCommands.ftCursorRead(String indexName, long cursorId, int count)	Deprecated.
Response<Long>	RediSearchPipelineCommands.ftDictAdd(String dictionary, String... terms)
Response<Long>	RediSearchPipelineCommands.ftDictAddBySampleKey(String indexName, String dictionary, String... terms)
Response<Long>	RediSearchPipelineCommands.ftDictDel(String dictionary, String... terms)
Response<Long>	RediSearchPipelineCommands.ftDictDelBySampleKey(String indexName, String dictionary, String... terms)
Response<Set<String>>	RediSearchPipelineCommands.ftDictDump(String dictionary)
Response<Set<String>>	RediSearchPipelineCommands.ftDictDumpBySampleKey(String indexName, String dictionary)
Response<String>	RediSearchPipelineCommands.ftDropIndex(String indexName)	Deprecated.
Response<String>	RediSearchPipelineCommands.ftDropIndexDD(String indexName)	Deprecated.
Response<String>	RediSearchPipelineCommands.ftExplain(String indexName, Query query)
Response<List<String>>	RediSearchPipelineCommands.ftExplainCLI(String indexName, Query query)
Response<Map<String,Object>>	RediSearchPipelineCommands.ftInfo(String indexName)
Response<SearchResult>	RediSearchPipelineCommands.ftSearch(byte[] indexName, Query query)
default Response<SearchResult>	RediSearchPipelineCommands.ftSearch(String indexName)
Response<SearchResult>	RediSearchPipelineCommands.ftSearch(String indexName, String query)
Response<SearchResult>	RediSearchPipelineCommands.ftSearch(String indexName, String query, FTSearchParams searchParams)
Response<SearchResult>	RediSearchPipelineCommands.ftSearch(String indexName, Query query)
Response<Map<String,Map<String,Double>>>	RediSearchPipelineCommands.ftSpellCheck(String index, String query)
Response<Map<String,Map<String,Double>>>	RediSearchPipelineCommands.ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams)
Response<Long>	RediSearchPipelineCommands.ftSugAdd(String key, String string, double score)
Response<Long>	RediSearchPipelineCommands.ftSugAddIncr(String key, String string, double score)
Response<Boolean>	RediSearchPipelineCommands.ftSugDel(String key, String string)
Response<List<String>>	RediSearchPipelineCommands.ftSugGet(String key, String prefix)
Response<List<String>>	RediSearchPipelineCommands.ftSugGet(String key, String prefix, boolean fuzzy, int max)
Response<List<Tuple>>	RediSearchPipelineCommands.ftSugGetWithScores(String key, String prefix)
Response<List<Tuple>>	RediSearchPipelineCommands.ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max)
Response<Long>	RediSearchPipelineCommands.ftSugLen(String key)
Response<Map<String,List<String>>>	RediSearchPipelineCommands.ftSynDump(String indexName)
Response<String>	RediSearchPipelineCommands.ftSynUpdate(String indexName, String synonymGroupId, String... terms)
Response<Set<String>>	RediSearchPipelineCommands.ftTagVals(String indexName, String fieldName)

Uses of Response in redis.clients.jedis.timeseries

Methods in redis.clients.jedis.timeseries that return Response

Modifier and Type	Method	Description
Response<Long>	RedisTimeSeriesPipelineCommands.tsAdd(String key, double value)
Response<Long>	RedisTimeSeriesPipelineCommands.tsAdd(String key, long timestamp, double value)
Response<Long>	RedisTimeSeriesPipelineCommands.tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
Response<String>	RedisTimeSeriesPipelineCommands.tsAlter(String key, TSAlterParams alterParams)
Response<String>	RedisTimeSeriesPipelineCommands.tsCreate(String key)
Response<String>	RedisTimeSeriesPipelineCommands.tsCreate(String key, TSCreateParams createParams)
Response<String>	RedisTimeSeriesPipelineCommands.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
Response<String>	RedisTimeSeriesPipelineCommands.tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp)
Response<Long>	RedisTimeSeriesPipelineCommands.tsDecrBy(String key, double value)
Response<Long>	RedisTimeSeriesPipelineCommands.tsDecrBy(String key, double value, long timestamp)
Response<Long>	RedisTimeSeriesPipelineCommands.tsDel(String key, long fromTimestamp, long toTimestamp)
Response<String>	RedisTimeSeriesPipelineCommands.tsDeleteRule(String sourceKey, String destKey)
Response<TSElement>	RedisTimeSeriesPipelineCommands.tsGet(String key)
Response<TSElement>	RedisTimeSeriesPipelineCommands.tsGet(String key, TSGetParams getParams)
Response<Long>	RedisTimeSeriesPipelineCommands.tsIncrBy(String key, double value)
Response<Long>	RedisTimeSeriesPipelineCommands.tsIncrBy(String key, double value, long timestamp)
Response<List<Long>>	RedisTimeSeriesPipelineCommands.tsMAdd(Map.Entry<String,TSElement>... entries)
Response<List<TSKeyValue<TSElement>>>	RedisTimeSeriesPipelineCommands.tsMGet(TSMGetParams multiGetParams, String... filters)
Response<List<TSKeyedElements>>	RedisTimeSeriesPipelineCommands.tsMRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	RedisTimeSeriesPipelineCommands.tsMRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	RedisTimeSeriesPipelineCommands.tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	RedisTimeSeriesPipelineCommands.tsMRevRange(TSMRangeParams multiRangeParams)
Response<List<String>>	RedisTimeSeriesPipelineCommands.tsQueryIndex(String... filters)
Response<List<TSElement>>	RedisTimeSeriesPipelineCommands.tsRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	RedisTimeSeriesPipelineCommands.tsRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	RedisTimeSeriesPipelineCommands.tsRevRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	RedisTimeSeriesPipelineCommands.tsRevRange(String key, TSRangeParams rangeParams)