Uses of Interface io.lettuce.core.RedisFuture (Lettuce (OSGi-enabled) 6.1.1.RELEASE API)

Packages that use RedisFuture
Package	Description
io.lettuce.core	The Redis client package containing `RedisClient` for Redis Standalone and Redis Sentinel operations.
io.lettuce.core.api.async	Standalone Redis API for asynchronous executed commands.
io.lettuce.core.cluster	Client for Redis Cluster, see `RedisClusterClient`.
io.lettuce.core.cluster.api.async	Redis Cluster API for asynchronous executed commands.
io.lettuce.core.internal	Contains internal API.
io.lettuce.core.protocol	Redis protocol layer abstraction.
io.lettuce.core.pubsub	Pub/Sub connection classes.
io.lettuce.core.pubsub.api.async	Pub/Sub Redis API for asynchronous executed commands.
io.lettuce.core.sentinel	Redis Sentinel connection classes.
io.lettuce.core.sentinel.api.async	Redis Sentinel API for asynchronous executed commands.

Uses of RedisFuture in io.lettuce.core

Methods in io.lettuce.core that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<Set<AclCategory>>`	AbstractRedisAsyncCommands.`aclCat()`
`RedisFuture<Set<CommandType>>`	AbstractRedisAsyncCommands.`aclCat(AclCategory category)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`aclDeluser(String... usernames)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclGenpass()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclGenpass(int bits)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`aclGetuser(String username)`
`RedisFuture<List<String>>`	AbstractRedisAsyncCommands.`aclList()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclLoad()`
`RedisFuture<List<Map<String,Object>>>`	AbstractRedisAsyncCommands.`aclLog()`
`RedisFuture<List<Map<String,Object>>>`	AbstractRedisAsyncCommands.`aclLog(int count)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclLogReset()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclSave()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclSetuser(String username, AclSetuserArgs args)`
`RedisFuture<List<String>>`	AbstractRedisAsyncCommands.`aclUsers()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`aclWhoami()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`append(K key, V value)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`asking()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`auth(char[] password)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`auth(CharSequence password)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`auth(String username, char[] password)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`auth(String username, CharSequence password)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`bgrewriteaof()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`bgsave()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitcount(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitcount(K key, long start, long end)`
`RedisFuture<List<Long>>`	AbstractRedisAsyncCommands.`bitfield(K key, BitFieldArgs bitFieldArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitopAnd(K destination, K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitopNot(K destination, K source)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitopOr(K destination, K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitopXor(K destination, K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitpos(K key, boolean state)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitpos(K key, boolean state, long start)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`bitpos(K key, boolean state, long start, long end)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`blmove(K source, K destination, LMoveArgs args, long timeout)`
`RedisFuture<KeyValue<K,V>>`	AbstractRedisAsyncCommands.`blpop(long timeout, K... keys)`
`RedisFuture<KeyValue<K,V>>`	AbstractRedisAsyncCommands.`brpop(long timeout, K... keys)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`brpoplpush(long timeout, K source, K destination)`
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	AbstractRedisAsyncCommands.`bzpopmax(long timeout, K... keys)`
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	AbstractRedisAsyncCommands.`bzpopmin(long timeout, K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientCaching(boolean enabled)`
`RedisFuture<K>`	AbstractRedisAsyncCommands.`clientGetname()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clientGetredir()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clientId()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clientKill(KillArgs killArgs)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientKill(String addr)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientList()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientPause(long timeout)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientSetname(K name)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clientTracking(TrackingArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clientUnblock(long id, UnblockType type)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterAddSlots(int... slots)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterBumpepoch()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clusterCountFailureReports(String nodeId)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clusterCountKeysInSlot(int slot)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterDelSlots(int... slots)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterFailover(boolean force)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterFlushslots()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterForget(String nodeId)`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`clusterGetKeysInSlot(int slot, int count)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterInfo()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`clusterKeyslot(K key)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterMeet(String ip, int port)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterMyId()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterNodes()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterReplicate(String nodeId)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterReset(boolean hard)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSaveconfig()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSetConfigEpoch(long configEpoch)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSetSlotImporting(int slot, String nodeId)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSetSlotMigrating(int slot, String nodeId)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSetSlotNode(int slot, String nodeId)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`clusterSetSlotStable(int slot)`
`RedisFuture<List<String>>`	AbstractRedisAsyncCommands.`clusterSlaves(String nodeId)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`clusterSlots()`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`command()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`commandCount()`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`commandInfo(CommandType... commands)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`commandInfo(String... commands)`
`RedisFuture<Map<String,String>>`	AbstractRedisAsyncCommands.`configGet(String parameter)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`configResetstat()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`configRewrite()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`configSet(String parameter, String value)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`copy(K source, K destination)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`copy(K source, K destination, CopyArgs copyArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`dbsize()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugCrashAndRecover(Long delay)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugHtstats(int db)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugObject(K key)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugReload()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugRestart(Long delay)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`debugSdslen(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`decr(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`decrby(K key, long amount)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`del(Iterable<K> keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`del(K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`discard()`
`protected <T> RedisFuture<T>`	AbstractRedisAsyncCommands.`dispatch(CommandType type, CommandOutput<K,V,T> output)`
`protected <T> RedisFuture<T>`	AbstractRedisAsyncCommands.`dispatch(CommandType type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`
`RedisFuture<byte[]>`	AbstractRedisAsyncCommands.`dump(K key)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`echo(V msg)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`eval(byte[] script, ScriptOutputType type, K... keys)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`eval(byte[] script, ScriptOutputType type, K[] keys, V... values)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`eval(String script, ScriptOutputType type, K... keys)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`eval(String script, ScriptOutputType type, K[] keys, V... values)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`evalsha(String digest, ScriptOutputType type, K... keys)`
`<T> RedisFuture<T>`	AbstractRedisAsyncCommands.`evalsha(String digest, ScriptOutputType type, K[] keys, V... values)`
`RedisFuture<TransactionResult>`	AbstractRedisAsyncCommands.`exec()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`exists(Iterable<K> keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`exists(K... keys)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`expire(K key, long seconds)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`expire(K key, Duration seconds)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`expireat(K key, long timestamp)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`expireat(K key, Instant timestamp)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`expireat(K key, Date timestamp)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushall()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushall(FlushMode flushMode)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushallAsync()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushdb()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushdb(FlushMode flushMode)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`flushdbAsync()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, double longitude, double latitude, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, double longitude, double latitude, V member, GeoAddArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, GeoAddArgs args, GeoValue<V>... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, GeoAddArgs args, Object... lngLatMember)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, GeoValue<V>... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geoadd(K key, Object... lngLatMember)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`geodist(K key, V from, V to, GeoArgs.Unit unit)`
`RedisFuture<List<Value<String>>>`	AbstractRedisAsyncCommands.`geohash(K key, V... members)`
`RedisFuture<List<GeoCoordinates>>`	AbstractRedisAsyncCommands.`geopos(K key, V... members)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	AbstractRedisAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`
`protected RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`
`protected RedisFuture<List<GeoWithin<V>>>`	AbstractRedisAsyncCommands.`georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	AbstractRedisAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`
`protected RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit)`
`protected RedisFuture<List<GeoWithin<V>>>`	AbstractRedisAsyncCommands.`georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate)`
`RedisFuture<List<GeoWithin<V>>>`	AbstractRedisAsyncCommands.`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`geosearchstore(K destination, K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs, boolean storeDist)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`get(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`getbit(K key, long offset)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`getdel(K key)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`getex(K key, GetExArgs args)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`getrange(K key, long start, long end)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`getset(K key, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hdel(K key, K... fields)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`hexists(K key, K field)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`hget(K key, K field)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hgetall(KeyValueStreamingChannel<K,V> channel, K key)`
`RedisFuture<Map<K,V>>`	AbstractRedisAsyncCommands.`hgetall(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hincrby(K key, K field, long amount)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`hincrbyfloat(K key, K field, double amount)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hkeys(KeyStreamingChannel<K> channel, K key)`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`hkeys(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hlen(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hmget(KeyValueStreamingChannel<K,V> channel, K key, K... fields)`
`RedisFuture<List<KeyValue<K,V>>>`	AbstractRedisAsyncCommands.`hmget(K key, K... fields)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`hmset(K key, Map<K,V> map)`
`RedisFuture<K>`	AbstractRedisAsyncCommands.`hrandfield(K key)`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`hrandfield(K key, long count)`
`RedisFuture<KeyValue<K,V>>`	AbstractRedisAsyncCommands.`hrandfieldWithvalues(K key)`
`RedisFuture<List<KeyValue<K,V>>>`	AbstractRedisAsyncCommands.`hrandfieldWithvalues(K key, long count)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanArgs scanArgs)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<MapScanCursor<K,V>>`	AbstractRedisAsyncCommands.`hscan(K key)`
`RedisFuture<MapScanCursor<K,V>>`	AbstractRedisAsyncCommands.`hscan(K key, ScanArgs scanArgs)`
`RedisFuture<MapScanCursor<K,V>>`	AbstractRedisAsyncCommands.`hscan(K key, ScanCursor scanCursor)`
`RedisFuture<MapScanCursor<K,V>>`	AbstractRedisAsyncCommands.`hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hset(K key, Map<K,V> map)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`hset(K key, K field, V value)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`hsetnx(K key, K field, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hstrlen(K key, K field)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`hvals(ValueStreamingChannel<V> channel, K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`hvals(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`incr(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`incrby(K key, long amount)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`incrbyfloat(K key, double amount)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`info()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`info(String section)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`keys(KeyStreamingChannel<K> channel, K pattern)`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`keys(K pattern)`
`RedisFuture<Date>`	AbstractRedisAsyncCommands.`lastsave()`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`lindex(K key, long index)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`linsert(K key, boolean before, V pivot, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`llen(K key)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`lmove(K source, K destination, LMoveArgs args)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`lpop(K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`lpop(K key, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lpos(K key, V value)`
`RedisFuture<List<Long>>`	AbstractRedisAsyncCommands.`lpos(K key, V value, int count)`
`RedisFuture<List<Long>>`	AbstractRedisAsyncCommands.`lpos(K key, V value, int count, LPosArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lpos(K key, V value, LPosArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lpush(K key, V... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lpushx(K key, V... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`lrange(K key, long start, long stop)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`lrem(K key, long count, V value)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`lset(K key, long index, V value)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`ltrim(K key, long start, long stop)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`memoryUsage(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`mget(KeyValueStreamingChannel<K,V> channel, Iterable<K> keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`mget(KeyValueStreamingChannel<K,V> channel, K... keys)`
`RedisFuture<List<KeyValue<K,V>>>`	AbstractRedisAsyncCommands.`mget(Iterable<K> keys)`
`RedisFuture<List<KeyValue<K,V>>>`	AbstractRedisAsyncCommands.`mget(K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`migrate(String host, int port, K key, int db, long timeout)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`move(K key, int db)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`mset(Map<K,V> map)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`msetnx(Map<K,V> map)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`multi()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`objectEncoding(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`objectFreq(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`objectIdletime(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`objectRefcount(K key)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`persist(K key)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`pexpire(K key, long milliseconds)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`pexpire(K key, Duration milliseconds)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`pexpireat(K key, long timestamp)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`pexpireat(K key, Instant timestamp)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`pexpireat(K key, Date timestamp)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`pfadd(K key, V... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`pfcount(K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`pfmerge(K destkey, K... sourcekeys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`ping()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`psetex(K key, long milliseconds, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`pttl(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`publish(K channel, V message)`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`pubsubChannels()`
`RedisFuture<List<K>>`	AbstractRedisAsyncCommands.`pubsubChannels(K channel)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`pubsubNumpat()`
`RedisFuture<Map<K,Long>>`	AbstractRedisAsyncCommands.`pubsubNumsub(K... channels)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`quit()`
`RedisFuture<K>`	AbstractRedisAsyncCommands.`randomkey()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`readOnly()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`readWrite()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`rename(K key, K newKey)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`renamenx(K key, K newKey)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`restore(K key, byte[] value, RestoreArgs args)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`restore(K key, long ttl, byte[] value)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`role()`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`rpop(K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`rpop(K key, long count)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`rpoplpush(K source, K destination)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`rpush(K key, V... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`rpushx(K key, V... values)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sadd(K key, V... members)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`save()`
`RedisFuture<KeyScanCursor<K>>`	AbstractRedisAsyncCommands.`scan()`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`scan(KeyStreamingChannel<K> channel)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<KeyScanCursor<K>>`	AbstractRedisAsyncCommands.`scan(ScanArgs scanArgs)`
`RedisFuture<KeyScanCursor<K>>`	AbstractRedisAsyncCommands.`scan(ScanCursor scanCursor)`
`RedisFuture<KeyScanCursor<K>>`	AbstractRedisAsyncCommands.`scan(ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`scard(K key)`
`RedisFuture<List<Boolean>>`	AbstractRedisAsyncCommands.`scriptExists(String... digests)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`scriptFlush()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`scriptFlush(FlushMode flushMode)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`scriptKill()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`scriptLoad(byte[] script)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`scriptLoad(String script)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sdiff(ValueStreamingChannel<V> channel, K... keys)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`sdiff(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sdiffstore(K destination, K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`select(int db)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`set(K key, V value)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`set(K key, V value, SetArgs setArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`setbit(K key, long offset, int value)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`setex(K key, long seconds, V value)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`setGet(K key, V value)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`setGet(K key, V value, SetArgs setArgs)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`setnx(K key, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`setrange(K key, long offset, V value)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sinter(ValueStreamingChannel<V> channel, K... keys)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`sinter(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sinterstore(K destination, K... keys)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`sismember(K key, V member)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`slaveof(String host, int port)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`slaveofNoOne()`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`slowlogGet()`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`slowlogGet(int count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`slowlogLen()`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`slowlogReset()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`smembers(ValueStreamingChannel<V> channel, K key)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`smembers(K key)`
`RedisFuture<List<Boolean>>`	AbstractRedisAsyncCommands.`smismember(K key, V... members)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`smove(K source, K destination, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sort(ValueStreamingChannel<V> channel, K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`sort(K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`sort(K key, SortArgs sortArgs)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sortStore(K key, SortArgs sortArgs, K destination)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`spop(K key)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`spop(K key, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`srandmember(ValueStreamingChannel<V> channel, K key, long count)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`srandmember(K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`srandmember(K key, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`srem(K key, V... members)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<ValueScanCursor<V>>`	AbstractRedisAsyncCommands.`sscan(K key)`
`RedisFuture<ValueScanCursor<V>>`	AbstractRedisAsyncCommands.`sscan(K key, ScanArgs scanArgs)`
`RedisFuture<ValueScanCursor<V>>`	AbstractRedisAsyncCommands.`sscan(K key, ScanCursor scanCursor)`
`RedisFuture<ValueScanCursor<V>>`	AbstractRedisAsyncCommands.`sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<StringMatchResult>`	AbstractRedisAsyncCommands.`stralgoLcs(StrAlgoArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`strlen(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sunion(ValueStreamingChannel<V> channel, K... keys)`
`RedisFuture<Set<V>>`	AbstractRedisAsyncCommands.`sunion(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`sunionstore(K destination, K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`swapdb(int db1, int db2)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`time()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`touch(Iterable<K> keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`touch(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`ttl(K key)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`type(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`unlink(Iterable<K> keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`unlink(K... keys)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`unwatch()`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`waitForReplication(int replicas, long timeout)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`watch(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xack(K key, K group, String... messageIds)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xadd(K key, XAddArgs args, Object... keysAndValues)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xadd(K key, XAddArgs args, Map<K,V> body)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xadd(K key, Object... keysAndValues)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xadd(K key, Map<K,V> body)`
`RedisFuture<ClaimedMessages<K,V>>`	AbstractRedisAsyncCommands.`xautoclaim(K key, XAutoClaimArgs<K> args)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xclaim(K key, Consumer<K> consumer, long minIdleTime, String... messageIds)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xclaim(K key, Consumer<K> consumer, XClaimArgs args, String... messageIds)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xdel(K key, String... messageIds)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xgroupCreate(XReadArgs.StreamOffset<K> offset, K group)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xgroupCreate(XReadArgs.StreamOffset<K> offset, K group, XGroupCreateArgs args)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`xgroupCreateconsumer(K key, Consumer<K> consumer)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xgroupDelconsumer(K key, Consumer<K> consumer)`
`RedisFuture<Boolean>`	AbstractRedisAsyncCommands.`xgroupDestroy(K key, K group)`
`RedisFuture<String>`	AbstractRedisAsyncCommands.`xgroupSetid(XReadArgs.StreamOffset<K> offset, K group)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`xinfoConsumers(K key, K group)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`xinfoGroups(K key)`
`RedisFuture<List<Object>>`	AbstractRedisAsyncCommands.`xinfoStream(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xlen(K key)`
`RedisFuture<List<PendingMessage>>`	AbstractRedisAsyncCommands.`xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)`
`RedisFuture<List<PendingMessage>>`	AbstractRedisAsyncCommands.`xpending(K key, XPendingArgs<K> args)`
`RedisFuture<PendingMessages>`	AbstractRedisAsyncCommands.`xpending(K key, K group)`
`RedisFuture<List<PendingMessage>>`	AbstractRedisAsyncCommands.`xpending(K key, K group, Range<String> range, Limit limit)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xrange(K key, Range<String> range)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xrange(K key, Range<String> range, Limit limit)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xread(XReadArgs.StreamOffset<K>... streams)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xread(XReadArgs args, XReadArgs.StreamOffset<K>... streams)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xreadgroup(Consumer<K> consumer, XReadArgs.StreamOffset<K>... streams)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xreadgroup(Consumer<K> consumer, XReadArgs args, XReadArgs.StreamOffset<K>... streams)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xrevrange(K key, Range<String> range)`
`RedisFuture<List<StreamMessage<K,V>>>`	AbstractRedisAsyncCommands.`xrevrange(K key, Range<String> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xtrim(K key, boolean approximateTrimming, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xtrim(K key, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`xtrim(K key, XTrimArgs args)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, double score, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, ScoredValue<V>... scoredValues)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, double score, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, ScoredValue<V>... scoredValues)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zadd(K key, Object... scoresAndValues)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`zaddincr(K key, double score, V member)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`zaddincr(K key, ZAddArgs zAddArgs, double score, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zcard(K key)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zcount(K key, double min, double max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zcount(K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zcount(K key, String min, String max)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zdiff(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zdiffstore(K destKey, K... srcKeys)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zdiffWithScores(K... keys)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`zincrby(K key, double amount, V member)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zinter(ZAggregateArgs aggregateArgs, K... keys)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zinter(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zinterstore(K destination, ZStoreArgs zStoreArgs, K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zinterstore(K destination, K... keys)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zinterWithScores(ZAggregateArgs aggregateArgs, K... keys)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zinterWithScores(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zlexcount(K key, Range<? extends V> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zlexcount(K key, String min, String max)`
`RedisFuture<List<Double>>`	AbstractRedisAsyncCommands.`zmscore(K key, V... members)`
`RedisFuture<ScoredValue<V>>`	AbstractRedisAsyncCommands.`zpopmax(K key)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zpopmax(K key, long count)`
`RedisFuture<ScoredValue<V>>`	AbstractRedisAsyncCommands.`zpopmin(K key)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zpopmin(K key, long count)`
`RedisFuture<V>`	AbstractRedisAsyncCommands.`zrandmember(K key)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrandmember(K key, long count)`
`RedisFuture<ScoredValue<V>>`	AbstractRedisAsyncCommands.`zrandmemberWithScores(K key)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrandmemberWithScores(K key, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrange(K key, long start, long stop)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebylex(K key, Range<? extends V> range)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebylex(K key, Range<? extends V> range, Limit limit)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebylex(K key, String min, String max)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebylex(K key, String min, String max, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, double min, double max)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, double min, double max, long offset, long count)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, Range<? extends Number> range)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, String min, String max)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrangebyscore(K key, String min, String max, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, double min, double max)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, double min, double max, long offset, long count)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, Range<? extends Number> range)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, String min, String max)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangebyscoreWithScores(K key, String min, String max, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrangeWithScores(K key, long start, long stop)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrank(K key, V member)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrem(K key, V... members)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebylex(K key, Range<? extends V> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebylex(K key, String min, String max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebyrank(K key, long start, long stop)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebyscore(K key, double min, double max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebyscore(K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zremrangebyscore(K key, String min, String max)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrange(K key, long start, long stop)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebylex(K key, Range<? extends V> range)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebylex(K key, Range<? extends V> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, double max, double min)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, double max, double min, long offset, long count)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, Range<? extends Number> range)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, String max, String min)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zrevrangebyscore(K key, String max, String min, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, double max, double min)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, Range<? extends Number> range)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, String max, String min)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zrevrangeWithScores(K key, long start, long stop)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zrevrank(K key, V member)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`
`RedisFuture<StreamScanCursor>`	AbstractRedisAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<ScoredValueScanCursor<V>>`	AbstractRedisAsyncCommands.`zscan(K key)`
`RedisFuture<ScoredValueScanCursor<V>>`	AbstractRedisAsyncCommands.`zscan(K key, ScanArgs scanArgs)`
`RedisFuture<ScoredValueScanCursor<V>>`	AbstractRedisAsyncCommands.`zscan(K key, ScanCursor scanCursor)`
`RedisFuture<ScoredValueScanCursor<V>>`	AbstractRedisAsyncCommands.`zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<Double>`	AbstractRedisAsyncCommands.`zscore(K key, V member)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zunion(ZAggregateArgs aggregateArgs, K... keys)`
`RedisFuture<List<V>>`	AbstractRedisAsyncCommands.`zunion(K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zunionstore(K destination, ZStoreArgs zStoreArgs, K... keys)`
`RedisFuture<Long>`	AbstractRedisAsyncCommands.`zunionstore(K destination, K... keys)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zunionWithScores(ZAggregateArgs aggregateArgs, K... keys)`
`RedisFuture<List<ScoredValue<V>>>`	AbstractRedisAsyncCommands.`zunionWithScores(K... keys)`

Methods in io.lettuce.core with parameters of type RedisFuture
Modifier and Type	Method	Description
`static <T> T`	LettuceFutures.`awaitOrCancel(RedisFuture<T> cmd, long timeout, TimeUnit unit)`	Wait until futures are complete or the supplied timeout is reached.

Uses of RedisFuture in io.lettuce.core.api.async

Methods in io.lettuce.core.api.async that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<Set<AclCategory>>`	RedisAclAsyncCommands.`aclCat()`	The command shows the available ACL categories if called without arguments.
`RedisFuture<Set<CommandType>>`	RedisAclAsyncCommands.`aclCat(AclCategory category)`	The command shows all the Redis commands in the specified category.
`RedisFuture<Long>`	RedisAclAsyncCommands.`aclDeluser(String... usernames)`	Delete all the specified ACL users and terminate all the connections that are authenticated with such users.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclGenpass()`	The command generates a password.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclGenpass(int bits)`	The command generates a password.
`RedisFuture<List<Object>>`	RedisAclAsyncCommands.`aclGetuser(String username)`	The command returns all the rules defined for an existing ACL user.
`RedisFuture<List<String>>`	RedisAclAsyncCommands.`aclList()`	The command shows the currently active ACL rules in the Redis server.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclLoad()`	When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.
`RedisFuture<List<Map<String,Object>>>`	RedisAclAsyncCommands.`aclLog()`	The command shows a list of recent ACL security events.
`RedisFuture<List<Map<String,Object>>>`	RedisAclAsyncCommands.`aclLog(int count)`	The command shows a list of recent ACL security events.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclLogReset()`	The command clears ACL security events.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclSave()`	When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclSetuser(String username, AclSetuserArgs setuserArgs)`	Create an ACL user with the specified rules or modify the rules of an existing user.
`RedisFuture<List<String>>`	RedisAclAsyncCommands.`aclUsers()`	The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
`RedisFuture<String>`	RedisAclAsyncCommands.`aclWhoami()`	The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
`RedisFuture<Long>`	RedisStringAsyncCommands.`append(K key, V value)`	Append a value to a key.
`RedisFuture<String>`	RedisAsyncCommands.`auth(CharSequence password)`	Authenticate to the server.
`RedisFuture<String>`	RedisAsyncCommands.`auth(String username, CharSequence password)`	Authenticate to the server with username and password.
`RedisFuture<String>`	RedisServerAsyncCommands.`bgrewriteaof()`	Asynchronously rewrite the append-only file.
`RedisFuture<String>`	RedisServerAsyncCommands.`bgsave()`	Asynchronously save the dataset to disk.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitcount(K key)`	Count set bits in a string.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitcount(K key, long start, long end)`	Count set bits in a string.
`RedisFuture<List<Long>>`	RedisStringAsyncCommands.`bitfield(K key, BitFieldArgs bitFieldArgs)`	Execute `BITFIELD` with its subcommands.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitopAnd(K destination, K... keys)`	Perform bitwise AND between strings.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitopNot(K destination, K source)`	Perform bitwise NOT between strings.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitopOr(K destination, K... keys)`	Perform bitwise OR between strings.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitopXor(K destination, K... keys)`	Perform bitwise XOR between strings.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitpos(K key, boolean state)`	Find first bit set or clear in a string.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitpos(K key, boolean state, long start)`	Find first bit set or clear in a string.
`RedisFuture<Long>`	RedisStringAsyncCommands.`bitpos(K key, boolean state, long start, long end)`	Find first bit set or clear in a string.
`RedisFuture<V>`	RedisListAsyncCommands.`blmove(K source, K destination, LMoveArgs args, long timeout)`	Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
`RedisFuture<KeyValue<K,V>>`	RedisListAsyncCommands.`blpop(long timeout, K... keys)`	Remove and get the first element in a list, or block until one is available.
`RedisFuture<KeyValue<K,V>>`	RedisListAsyncCommands.`brpop(long timeout, K... keys)`	Remove and get the last element in a list, or block until one is available.
`RedisFuture<V>`	RedisListAsyncCommands.`brpoplpush(long timeout, K source, K destination)`	Pop a value from a list, push it to another list and return it; or block until one is available.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`bzpopmax(long timeout, K... keys)`	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`bzpopmin(long timeout, K... keys)`	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientCaching(boolean enabled)`	Control tracking of keys in the context of server-assisted client cache invalidation.
`RedisFuture<K>`	RedisServerAsyncCommands.`clientGetname()`	Get the current connection name.
`RedisFuture<Long>`	RedisServerAsyncCommands.`clientGetredir()`	Returns the client ID we are redirecting our tracking notifications to.
`RedisFuture<Long>`	RedisServerAsyncCommands.`clientId()`	Get the id of the current connection.
`RedisFuture<Long>`	RedisServerAsyncCommands.`clientKill(KillArgs killArgs)`	Kill connections of clients which are filtered by `killArgs`.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientKill(String addr)`	Kill the connection of a client identified by ip:port.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientList()`	Get the list of client connections.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientPause(long timeout)`	Stop processing commands from clients for some time.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientSetname(K name)`	Set the current connection name.
`RedisFuture<String>`	RedisServerAsyncCommands.`clientTracking(TrackingArgs args)`	Enables the tracking feature of the Redis server, that is used for server assisted client side caching.
`RedisFuture<Long>`	RedisServerAsyncCommands.`clientUnblock(long id, UnblockType type)`	Unblock the specified blocked client.
`RedisFuture<List<Object>>`	RedisServerAsyncCommands.`command()`	Returns an array reply of details about all Redis commands.
`RedisFuture<Long>`	RedisServerAsyncCommands.`commandCount()`	Get total number of Redis commands.
`RedisFuture<List<Object>>`	RedisServerAsyncCommands.`commandInfo(CommandType... commands)`	Returns an array reply of details about the requested commands.
`RedisFuture<List<Object>>`	RedisServerAsyncCommands.`commandInfo(String... commands)`	Returns an array reply of details about the requested commands.
`RedisFuture<Map<String,String>>`	RedisServerAsyncCommands.`configGet(String parameter)`	Get the value of a configuration parameter.
`RedisFuture<String>`	RedisServerAsyncCommands.`configResetstat()`	Reset the stats returned by INFO.
`RedisFuture<String>`	RedisServerAsyncCommands.`configRewrite()`	Rewrite the configuration file with the in memory configuration.
`RedisFuture<String>`	RedisServerAsyncCommands.`configSet(String parameter, String value)`	Set a configuration parameter to the given value.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`copy(K source, K destination)`	Copy the value stored at the source key to the destination key.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`copy(K source, K destination, CopyArgs copyArgs)`	Copy the value stored at the source key to the destination key.
`RedisFuture<Long>`	RedisServerAsyncCommands.`dbsize()`	Return the number of keys in the selected database.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugCrashAndRecover(Long delay)`	Crash and recover.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugHtstats(int db)`	Get debugging information about the internal hash-table state.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugObject(K key)`	Get debugging information about a key.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugReload()`	Save RDB, clear the database and reload RDB.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugRestart(Long delay)`	Restart the server gracefully.
`RedisFuture<String>`	RedisServerAsyncCommands.`debugSdslen(K key)`	Get debugging information about the internal SDS length.
`RedisFuture<Long>`	RedisStringAsyncCommands.`decr(K key)`	Decrement the integer value of a key by one.
`RedisFuture<Long>`	RedisStringAsyncCommands.`decrby(K key, long amount)`	Decrement the integer value of a key by the given number.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`del(K... keys)`	Delete one or more keys.
`RedisFuture<String>`	RedisTransactionalAsyncCommands.`discard()`	Discard all commands issued after MULTI.
`<T> RedisFuture<T>`	BaseRedisAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output)`	Dispatch a command to the Redis Server.
`<T> RedisFuture<T>`	BaseRedisAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`	Dispatch a command to the Redis Server.
`RedisFuture<byte[]>`	RedisKeyAsyncCommands.`dump(K key)`	Return a serialized version of the value stored at the specified key.
`RedisFuture<V>`	BaseRedisAsyncCommands.`echo(V msg)`	Echo the given string.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`eval(byte[] script, ScriptOutputType type, K... keys)`	Execute a Lua script server side.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`eval(byte[] script, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`eval(String script, ScriptOutputType type, K... keys)`	Execute a Lua script server side.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`eval(String script, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`evalsha(String digest, ScriptOutputType type, K... keys)`	Evaluates a script cached on the server side by its SHA1 digest.
`<T> RedisFuture<T>`	RedisScriptingAsyncCommands.`evalsha(String digest, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`RedisFuture<TransactionResult>`	RedisTransactionalAsyncCommands.`exec()`	Execute all commands issued after MULTI.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`exists(K... keys)`	Determine how many keys exist.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`expire(K key, long seconds)`	Set a key's time to live in seconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`expire(K key, Duration seconds)`	Set a key's time to live in seconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`expireat(K key, long timestamp)`	Set the expiration for a key as a UNIX timestamp.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`expireat(K key, Instant timestamp)`	Set the expiration for a key as a UNIX timestamp.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`expireat(K key, Date timestamp)`	Set the expiration for a key as a UNIX timestamp.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushall()`	Remove all keys from all databases.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushall(FlushMode flushMode)`	Remove all keys from all databases using the specified `FlushMode`.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushallAsync()`	Deprecated. since 6.1, use `RedisServerAsyncCommands.flushall(FlushMode)` instead.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushdb()`	Remove all keys from the current database.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushdb(FlushMode flushMode)`	Remove all keys from the current database using the specified `FlushMode`.
`RedisFuture<String>`	RedisServerAsyncCommands.`flushdbAsync()`	Deprecated. since 6.1, use `RedisServerAsyncCommands.flushdb(FlushMode)` instead.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, double longitude, double latitude, V member)`	Single geo add.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, double longitude, double latitude, V member, GeoAddArgs args)`	Single geo add.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, GeoAddArgs args, GeoValue<V>... values)`	Multi geo add.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, GeoAddArgs args, Object... lngLatMember)`	Multi geo add.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, GeoValue<V>... values)`	Multi geo add.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geoadd(K key, Object... lngLatMember)`	Multi geo add.
`RedisFuture<Double>`	RedisGeoAsyncCommands.`geodist(K key, V from, V to, GeoArgs.Unit unit)`	Retrieve distance between points `from` and `to`.
`RedisFuture<List<Value<String>>>`	RedisGeoAsyncCommands.`geohash(K key, V... members)`	Retrieve Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index.
`RedisFuture<List<GeoCoordinates>>`	RedisGeoAsyncCommands.`geopos(K key, V... members)`	Get geo coordinates for the `members`.
`RedisFuture<Set<V>>`	RedisGeoAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`	Retrieve members selected by distance with the center of `longitude` and `latitude`.
`RedisFuture<List<GeoWithin<V>>>`	RedisGeoAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `longitude` and `latitude`.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`	Perform a `RedisGeoAsyncCommands.georadius(Object, double, double, double, GeoArgs.Unit, GeoArgs)` query and store the results in a sorted set.
`RedisFuture<Set<V>>`	RedisGeoAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)`	Retrieve members selected by distance with the center of `member`.
`RedisFuture<List<GeoWithin<V>>>`	RedisGeoAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `member`.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`	Perform a `RedisGeoAsyncCommands.georadiusbymember(Object, Object, double, GeoArgs.Unit, GeoArgs)` query and store the results in a sorted set.
`RedisFuture<Set<V>>`	RedisGeoAsyncCommands.`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate)`	Retrieve members selected by distance with the center of `reference` the search `predicate`.
`RedisFuture<List<GeoWithin<V>>>`	RedisGeoAsyncCommands.`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `reference` the search `predicate`.
`RedisFuture<Long>`	RedisGeoAsyncCommands.`geosearchstore(K destination, K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs, boolean storeDist)`	Perform a `RedisGeoAsyncCommands.geosearch(Object, GeoSearch.GeoRef, GeoSearch.GeoPredicate, GeoArgs)` query and store the results in a sorted set.
`RedisFuture<V>`	RedisStringAsyncCommands.`get(K key)`	Get the value of a key.
`RedisFuture<Long>`	RedisStringAsyncCommands.`getbit(K key, long offset)`	Returns the bit value at offset in the string value stored at key.
`RedisFuture<V>`	RedisStringAsyncCommands.`getdel(K key)`	Get the value of key and delete the key.
`RedisFuture<V>`	RedisStringAsyncCommands.`getex(K key, GetExArgs args)`	Get the value of key and optionally set its expiration.
`RedisFuture<V>`	RedisStringAsyncCommands.`getrange(K key, long start, long end)`	Get a substring of the string stored at a key.
`RedisFuture<V>`	RedisStringAsyncCommands.`getset(K key, V value)`	Set the string value of a key and return its old value.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hdel(K key, K... fields)`	Delete one or more hash fields.
`RedisFuture<Boolean>`	RedisHashAsyncCommands.`hexists(K key, K field)`	Determine if a hash field exists.
`RedisFuture<V>`	RedisHashAsyncCommands.`hget(K key, K field)`	Get the value of a hash field.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hgetall(KeyValueStreamingChannel<K,V> channel, K key)`	Stream over all the fields and values in a hash.
`RedisFuture<Map<K,V>>`	RedisHashAsyncCommands.`hgetall(K key)`	Get all the fields and values in a hash.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hincrby(K key, K field, long amount)`	Increment the integer value of a hash field by the given number.
`RedisFuture<Double>`	RedisHashAsyncCommands.`hincrbyfloat(K key, K field, double amount)`	Increment the float value of a hash field by the given amount.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hkeys(KeyStreamingChannel<K> channel, K key)`	Stream over all the fields in a hash.
`RedisFuture<List<K>>`	RedisHashAsyncCommands.`hkeys(K key)`	Get all the fields in a hash.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hlen(K key)`	Get the number of fields in a hash.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hmget(KeyValueStreamingChannel<K,V> channel, K key, K... fields)`	Stream over the values of all the given hash fields.
`RedisFuture<List<KeyValue<K,V>>>`	RedisHashAsyncCommands.`hmget(K key, K... fields)`	Get the values of all the given hash fields.
`RedisFuture<String>`	RedisHashAsyncCommands.`hmset(K key, Map<K,V> map)`	Set multiple hash fields to multiple values.
`RedisFuture<K>`	RedisHashAsyncCommands.`hrandfield(K key)`	Return a random field from the hash stored at `key`.
`RedisFuture<List<K>>`	RedisHashAsyncCommands.`hrandfield(K key, long count)`	Return `count` random fields from the hash stored at `key`.
`RedisFuture<KeyValue<K,V>>`	RedisHashAsyncCommands.`hrandfieldWithvalues(K key)`	Return a random field along its value from the hash stored at `key`.
`RedisFuture<List<KeyValue<K,V>>>`	RedisHashAsyncCommands.`hrandfieldWithvalues(K key, long count)`	Return `count` random fields along their value from the hash stored at `key`.
`RedisFuture<StreamScanCursor>`	RedisHashAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key)`	Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	RedisHashAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	RedisHashAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	RedisHashAsyncCommands.`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	RedisHashAsyncCommands.`hscan(K key)`	Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	RedisHashAsyncCommands.`hscan(K key, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	RedisHashAsyncCommands.`hscan(K key, ScanCursor scanCursor)`	Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	RedisHashAsyncCommands.`hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hset(K key, Map<K,V> map)`	Set multiple hash fields to multiple values.
`RedisFuture<Boolean>`	RedisHashAsyncCommands.`hset(K key, K field, V value)`	Set the string value of a hash field.
`RedisFuture<Boolean>`	RedisHashAsyncCommands.`hsetnx(K key, K field, V value)`	Set the value of a hash field, only if the field does not exist.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hstrlen(K key, K field)`	Get the string length of the field value in a hash.
`RedisFuture<Long>`	RedisHashAsyncCommands.`hvals(ValueStreamingChannel<V> channel, K key)`	Stream over all the values in a hash.
`RedisFuture<List<V>>`	RedisHashAsyncCommands.`hvals(K key)`	Get all the values in a hash.
`RedisFuture<Long>`	RedisStringAsyncCommands.`incr(K key)`	Increment the integer value of a key by one.
`RedisFuture<Long>`	RedisStringAsyncCommands.`incrby(K key, long amount)`	Increment the integer value of a key by the given amount.
`RedisFuture<Double>`	RedisStringAsyncCommands.`incrbyfloat(K key, double amount)`	Increment the float value of a key by the given amount.
`RedisFuture<String>`	RedisServerAsyncCommands.`info()`	Get information and statistics about the server.
`RedisFuture<String>`	RedisServerAsyncCommands.`info(String section)`	Get information and statistics about the server.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`keys(KeyStreamingChannel<K> channel, K pattern)`	Find all keys matching the given pattern.
`RedisFuture<List<K>>`	RedisKeyAsyncCommands.`keys(K pattern)`	Find all keys matching the given pattern.
`RedisFuture<Date>`	RedisServerAsyncCommands.`lastsave()`	Get the UNIX time stamp of the last successful save to disk.
`RedisFuture<V>`	RedisListAsyncCommands.`lindex(K key, long index)`	Get an element from a list by its index.
`RedisFuture<Long>`	RedisListAsyncCommands.`linsert(K key, boolean before, V pivot, V value)`	Insert an element before or after another element in a list.
`RedisFuture<Long>`	RedisListAsyncCommands.`llen(K key)`	Get the length of a list.
`RedisFuture<V>`	RedisListAsyncCommands.`lmove(K source, K destination, LMoveArgs args)`	Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
`RedisFuture<V>`	RedisListAsyncCommands.`lpop(K key)`	Remove and get the first element in a list.
`RedisFuture<List<V>>`	RedisListAsyncCommands.`lpop(K key, long count)`	Remove and get the first `count` elements in a list.
`RedisFuture<Long>`	RedisListAsyncCommands.`lpos(K key, V value)`	Return the index of matching elements inside a Redis list.
`RedisFuture<List<Long>>`	RedisListAsyncCommands.`lpos(K key, V value, int count)`	Return the index of matching elements inside a Redis list using the `COUNT` option.
`RedisFuture<List<Long>>`	RedisListAsyncCommands.`lpos(K key, V value, int count, LPosArgs args)`	Return the index of matching elements inside a Redis list using the `COUNT` option.
`RedisFuture<Long>`	RedisListAsyncCommands.`lpos(K key, V value, LPosArgs args)`	Return the index of matching elements inside a Redis list.
`RedisFuture<Long>`	RedisListAsyncCommands.`lpush(K key, V... values)`	Prepend one or multiple values to a list.
`RedisFuture<Long>`	RedisListAsyncCommands.`lpushx(K key, V... values)`	Prepend values to a list, only if the list exists.
`RedisFuture<Long>`	RedisListAsyncCommands.`lrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Get a range of elements from a list.
`RedisFuture<List<V>>`	RedisListAsyncCommands.`lrange(K key, long start, long stop)`	Get a range of elements from a list.
`RedisFuture<Long>`	RedisListAsyncCommands.`lrem(K key, long count, V value)`	Remove elements from a list.
`RedisFuture<String>`	RedisListAsyncCommands.`lset(K key, long index, V value)`	Set the value of an element in a list by its index.
`RedisFuture<String>`	RedisListAsyncCommands.`ltrim(K key, long start, long stop)`	Trim a list to the specified range.
`RedisFuture<Long>`	RedisServerAsyncCommands.`memoryUsage(K key)`	Reports the number of bytes that a key and its value require to be stored in RAM.
`RedisFuture<Long>`	RedisStringAsyncCommands.`mget(KeyValueStreamingChannel<K,V> channel, K... keys)`	Stream over the values of all the given keys.
`RedisFuture<List<KeyValue<K,V>>>`	RedisStringAsyncCommands.`mget(K... keys)`	Get the values of all the given keys.
`RedisFuture<String>`	RedisKeyAsyncCommands.`migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs)`	Atomically transfer one or more keys from a Redis instance to another one.
`RedisFuture<String>`	RedisKeyAsyncCommands.`migrate(String host, int port, K key, int db, long timeout)`	Atomically transfer a key from a Redis instance to another one.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`move(K key, int db)`	Move a key to another database.
`RedisFuture<String>`	RedisStringAsyncCommands.`mset(Map<K,V> map)`	Set multiple keys to multiple values.
`RedisFuture<Boolean>`	RedisStringAsyncCommands.`msetnx(Map<K,V> map)`	Set multiple keys to multiple values, only if none of the keys exist.
`RedisFuture<String>`	RedisTransactionalAsyncCommands.`multi()`	Mark the start of a transaction block.
`RedisFuture<String>`	RedisKeyAsyncCommands.`objectEncoding(K key)`	Returns the kind of internal representation used in order to store the value associated with the `key`.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`objectFreq(K key)`	Returns the logarithmic access frequency counter of the object stored at the specified `key`.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`objectIdletime(K key)`	Returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
`RedisFuture<Long>`	RedisKeyAsyncCommands.`objectRefcount(K key)`	Returns the number of references of the value associated with the specified key.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`persist(K key)`	Remove the expiration from a key.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`pexpire(K key, long milliseconds)`	Set a key's time to live in milliseconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`pexpire(K key, Duration milliseconds)`	Set a key's time to live in milliseconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`pexpireat(K key, long timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`pexpireat(K key, Instant timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`pexpireat(K key, Date timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`RedisFuture<Long>`	RedisHLLAsyncCommands.`pfadd(K key, V... values)`	Adds the specified elements to the specified HyperLogLog.
`RedisFuture<Long>`	RedisHLLAsyncCommands.`pfcount(K... keys)`	Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`RedisFuture<String>`	RedisHLLAsyncCommands.`pfmerge(K destkey, K... sourcekeys)`	Merge N different HyperLogLogs into a single one.
`RedisFuture<String>`	BaseRedisAsyncCommands.`ping()`	Ping the server.
`RedisFuture<String>`	RedisStringAsyncCommands.`psetex(K key, long milliseconds, V value)`	Set the value and expiration in milliseconds of a key.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`pttl(K key)`	Get the time to live for a key in milliseconds.
`RedisFuture<Long>`	BaseRedisAsyncCommands.`publish(K channel, V message)`	Post a message to a channel.
`RedisFuture<List<K>>`	BaseRedisAsyncCommands.`pubsubChannels()`	Lists the currently active channels.
`RedisFuture<List<K>>`	BaseRedisAsyncCommands.`pubsubChannels(K channel)`	Lists the currently active channels.
`RedisFuture<Long>`	BaseRedisAsyncCommands.`pubsubNumpat()`	Returns the number of subscriptions to patterns.
`RedisFuture<Map<K,Long>>`	BaseRedisAsyncCommands.`pubsubNumsub(K... channels)`	Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
`RedisFuture<String>`	BaseRedisAsyncCommands.`quit()`	Instructs Redis to disconnect the connection.
`RedisFuture<K>`	RedisKeyAsyncCommands.`randomkey()`	Return a random key from the keyspace.
`RedisFuture<String>`	BaseRedisAsyncCommands.`readOnly()`	Switch connection to Read-Only mode when connecting to a cluster.
`RedisFuture<String>`	BaseRedisAsyncCommands.`readWrite()`	Switch connection to Read-Write mode (default) when connecting to a cluster.
`RedisFuture<String>`	RedisKeyAsyncCommands.`rename(K key, K newKey)`	Rename a key.
`RedisFuture<Boolean>`	RedisKeyAsyncCommands.`renamenx(K key, K newKey)`	Rename a key, only if the new key does not exist.
`RedisFuture<String>`	RedisKeyAsyncCommands.`restore(K key, byte[] value, RestoreArgs args)`	Create a key using the provided serialized value, previously obtained using DUMP.
`RedisFuture<String>`	RedisKeyAsyncCommands.`restore(K key, long ttl, byte[] value)`	Create a key using the provided serialized value, previously obtained using DUMP.
`RedisFuture<List<Object>>`	BaseRedisAsyncCommands.`role()`	Return the role of the instance in the context of replication.
`RedisFuture<V>`	RedisListAsyncCommands.`rpop(K key)`	Remove and get the last element in a list.
`RedisFuture<List<V>>`	RedisListAsyncCommands.`rpop(K key, long count)`	Remove and get the last `count` elements in a list.
`RedisFuture<V>`	RedisListAsyncCommands.`rpoplpush(K source, K destination)`	Remove the last element in a list, append it to another list and return it.
`RedisFuture<Long>`	RedisListAsyncCommands.`rpush(K key, V... values)`	Append one or multiple values to a list.
`RedisFuture<Long>`	RedisListAsyncCommands.`rpushx(K key, V... values)`	Append values to a list, only if the list exists.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sadd(K key, V... members)`	Add one or more members to a set.
`RedisFuture<String>`	RedisServerAsyncCommands.`save()`	Synchronously save the dataset to disk.
`RedisFuture<KeyScanCursor<K>>`	RedisKeyAsyncCommands.`scan()`	Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	RedisKeyAsyncCommands.`scan(KeyStreamingChannel<K> channel)`	Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	RedisKeyAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	RedisKeyAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)`	Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	RedisKeyAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	RedisKeyAsyncCommands.`scan(ScanArgs scanArgs)`	Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	RedisKeyAsyncCommands.`scan(ScanCursor scanCursor)`	Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	RedisKeyAsyncCommands.`scan(ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`RedisFuture<Long>`	RedisSetAsyncCommands.`scard(K key)`	Get the number of members in a set.
`RedisFuture<List<Boolean>>`	RedisScriptingAsyncCommands.`scriptExists(String... digests)`	Check existence of scripts in the script cache.
`RedisFuture<String>`	RedisScriptingAsyncCommands.`scriptFlush()`	Remove all the scripts from the script cache.
`RedisFuture<String>`	RedisScriptingAsyncCommands.`scriptFlush(FlushMode flushMode)`	Remove all the scripts from the script cache using the specified `FlushMode`.
`RedisFuture<String>`	RedisScriptingAsyncCommands.`scriptKill()`	Kill the script currently in execution.
`RedisFuture<String>`	RedisScriptingAsyncCommands.`scriptLoad(byte[] script)`	Load the specified Lua script into the script cache.
`RedisFuture<String>`	RedisScriptingAsyncCommands.`scriptLoad(String script)`	Load the specified Lua script into the script cache.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sdiff(ValueStreamingChannel<V> channel, K... keys)`	Subtract multiple sets.
`RedisFuture<Set<V>>`	RedisSetAsyncCommands.`sdiff(K... keys)`	Subtract multiple sets.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sdiffstore(K destination, K... keys)`	Subtract multiple sets and store the resulting set in a key.
`RedisFuture<String>`	RedisAsyncCommands.`select(int db)`	Change the selected database for the current connection.
`RedisFuture<String>`	RedisStringAsyncCommands.`set(K key, V value)`	Set the string value of a key.
`RedisFuture<String>`	RedisStringAsyncCommands.`set(K key, V value, SetArgs setArgs)`	Set the string value of a key.
`RedisFuture<Long>`	RedisStringAsyncCommands.`setbit(K key, long offset, int value)`	Sets or clears the bit at offset in the string value stored at key.
`RedisFuture<String>`	RedisStringAsyncCommands.`setex(K key, long seconds, V value)`	Set the value and expiration of a key.
`RedisFuture<V>`	RedisStringAsyncCommands.`setGet(K key, V value)`	Set the string value of a key and return its old value.
`RedisFuture<V>`	RedisStringAsyncCommands.`setGet(K key, V value, SetArgs setArgs)`	Set the string value of a key and return its old value.
`RedisFuture<Boolean>`	RedisStringAsyncCommands.`setnx(K key, V value)`	Set the value of a key, only if the key does not exist.
`RedisFuture<Long>`	RedisStringAsyncCommands.`setrange(K key, long offset, V value)`	Overwrite part of a string at key starting at the specified offset.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sinter(ValueStreamingChannel<V> channel, K... keys)`	Intersect multiple sets.
`RedisFuture<Set<V>>`	RedisSetAsyncCommands.`sinter(K... keys)`	Intersect multiple sets.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sinterstore(K destination, K... keys)`	Intersect multiple sets and store the resulting set in a key.
`RedisFuture<Boolean>`	RedisSetAsyncCommands.`sismember(K key, V member)`	Determine if a given value is a member of a set.
`RedisFuture<String>`	RedisServerAsyncCommands.`slaveof(String host, int port)`	Make the server a replica of another instance, or promote it as master.
`RedisFuture<String>`	RedisServerAsyncCommands.`slaveofNoOne()`	Promote server as master.
`RedisFuture<List<Object>>`	RedisServerAsyncCommands.`slowlogGet()`	Read the slow log.
`RedisFuture<List<Object>>`	RedisServerAsyncCommands.`slowlogGet(int count)`	Read the slow log.
`RedisFuture<Long>`	RedisServerAsyncCommands.`slowlogLen()`	Obtaining the current length of the slow log.
`RedisFuture<String>`	RedisServerAsyncCommands.`slowlogReset()`	Resetting the slow log.
`RedisFuture<Long>`	RedisSetAsyncCommands.`smembers(ValueStreamingChannel<V> channel, K key)`	Get all the members in a set.
`RedisFuture<Set<V>>`	RedisSetAsyncCommands.`smembers(K key)`	Get all the members in a set.
`RedisFuture<List<Boolean>>`	RedisSetAsyncCommands.`smismember(K key, V... members)`	Returns whether each member is a member of the set stored at key.
`RedisFuture<Boolean>`	RedisSetAsyncCommands.`smove(K source, K destination, V member)`	Move a member from one set to another.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`sort(ValueStreamingChannel<V> channel, K key)`	Sort the elements in a list, set or sorted set.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs)`	Sort the elements in a list, set or sorted set.
`RedisFuture<List<V>>`	RedisKeyAsyncCommands.`sort(K key)`	Sort the elements in a list, set or sorted set.
`RedisFuture<List<V>>`	RedisKeyAsyncCommands.`sort(K key, SortArgs sortArgs)`	Sort the elements in a list, set or sorted set.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`sortStore(K key, SortArgs sortArgs, K destination)`	Sort the elements in a list, set or sorted set.
`RedisFuture<V>`	RedisSetAsyncCommands.`spop(K key)`	Remove and return a random member from a set.
`RedisFuture<Set<V>>`	RedisSetAsyncCommands.`spop(K key, long count)`	Remove and return one or multiple random members from a set.
`RedisFuture<Long>`	RedisSetAsyncCommands.`srandmember(ValueStreamingChannel<V> channel, K key, long count)`	Get one or multiple random members from a set.
`RedisFuture<V>`	RedisSetAsyncCommands.`srandmember(K key)`	Get one random member from a set.
`RedisFuture<List<V>>`	RedisSetAsyncCommands.`srandmember(K key, long count)`	Get one or multiple random members from a set.
`RedisFuture<Long>`	RedisSetAsyncCommands.`srem(K key, V... members)`	Remove one or more members from a set.
`RedisFuture<StreamScanCursor>`	RedisSetAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key)`	Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	RedisSetAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	RedisSetAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	RedisSetAsyncCommands.`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	RedisSetAsyncCommands.`sscan(K key)`	Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	RedisSetAsyncCommands.`sscan(K key, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	RedisSetAsyncCommands.`sscan(K key, ScanCursor scanCursor)`	Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	RedisSetAsyncCommands.`sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`RedisFuture<StringMatchResult>`	RedisStringAsyncCommands.`stralgoLcs(StrAlgoArgs strAlgoArgs)`	The STRALGO command implements complex algorithms that operate on strings.
`RedisFuture<Long>`	RedisStringAsyncCommands.`strlen(K key)`	Get the length of the value stored in a key.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sunion(ValueStreamingChannel<V> channel, K... keys)`	Add multiple sets.
`RedisFuture<Set<V>>`	RedisSetAsyncCommands.`sunion(K... keys)`	Add multiple sets.
`RedisFuture<Long>`	RedisSetAsyncCommands.`sunionstore(K destination, K... keys)`	Add multiple sets and store the resulting set in a key.
`RedisFuture<String>`	RedisAsyncCommands.`swapdb(int db1, int db2)`	Swap two Redis databases, so that immediately all the clients connected to a given DB will see the data of the other DB, and the other way around
`RedisFuture<List<V>>`	RedisServerAsyncCommands.`time()`	Return the current server time.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`touch(K... keys)`	Touch one or more keys.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`ttl(K key)`	Get the time to live for a key.
`RedisFuture<String>`	RedisKeyAsyncCommands.`type(K key)`	Determine the type stored at key.
`RedisFuture<Long>`	RedisKeyAsyncCommands.`unlink(K... keys)`	Unlink one or more keys (non blocking DEL).
`RedisFuture<String>`	RedisTransactionalAsyncCommands.`unwatch()`	Forget about all watched keys.
`RedisFuture<Long>`	BaseRedisAsyncCommands.`waitForReplication(int replicas, long timeout)`	Wait for replication.
`RedisFuture<String>`	RedisTransactionalAsyncCommands.`watch(K... keys)`	Watch the given keys to determine execution of the MULTI/EXEC block.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xack(K key, K group, String... messageIds)`	Acknowledge one or more messages as processed.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xadd(K key, XAddArgs args, Object... keysAndValues)`	Append a message to the stream `key`.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xadd(K key, XAddArgs args, Map<K,V> body)`	Append a message to the stream `key`.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xadd(K key, Object... keysAndValues)`	Append a message to the stream `key`.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xadd(K key, Map<K,V> body)`	Append a message to the stream `key`.
`RedisFuture<ClaimedMessages<K,V>>`	RedisStreamAsyncCommands.`xautoclaim(K key, XAutoClaimArgs<K> args)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xclaim(K key, Consumer<K> consumer, long minIdleTime, String... messageIds)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xclaim(K key, Consumer<K> consumer, XClaimArgs args, String... messageIds)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xdel(K key, String... messageIds)`	Removes the specified entries from the stream.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group)`	Create a consumer group.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group, XGroupCreateArgs args)`	Create a consumer group.
`RedisFuture<Boolean>`	RedisStreamAsyncCommands.`xgroupCreateconsumer(K key, Consumer<K> consumer)`	Create a consumer from a consumer group.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xgroupDelconsumer(K key, Consumer<K> consumer)`	Delete a consumer from a consumer group.
`RedisFuture<Boolean>`	RedisStreamAsyncCommands.`xgroupDestroy(K key, K group)`	Destroy a consumer group.
`RedisFuture<String>`	RedisStreamAsyncCommands.`xgroupSetid(XReadArgs.StreamOffset<K> streamOffset, K group)`	Set the current `group` id.
`RedisFuture<List<Object>>`	RedisStreamAsyncCommands.`xinfoConsumers(K key, K group)`	Retrieve information about consumer groups of group `group` and stream at `key`.
`RedisFuture<List<Object>>`	RedisStreamAsyncCommands.`xinfoGroups(K key)`	Retrieve information about the stream consumer groups at `key`.
`RedisFuture<List<Object>>`	RedisStreamAsyncCommands.`xinfoStream(K key)`	Retrieve information about the stream at `key`.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xlen(K key)`	Get the length of a steam.
`RedisFuture<List<PendingMessage>>`	RedisStreamAsyncCommands.`xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)`	Read pending messages from a stream within a specific `Range`.
`RedisFuture<List<PendingMessage>>`	RedisStreamAsyncCommands.`xpending(K key, XPendingArgs<K> args)`	Read pending messages from a stream within a specific `XPendingArgs`.
`RedisFuture<PendingMessages>`	RedisStreamAsyncCommands.`xpending(K key, K group)`	Read pending messages from a stream for a `group`.
`RedisFuture<List<PendingMessage>>`	RedisStreamAsyncCommands.`xpending(K key, K group, Range<String> range, Limit limit)`	Read pending messages from a stream within a specific `Range`.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xrange(K key, Range<String> range)`	Read messages from a stream within a specific `Range`.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xrange(K key, Range<String> range, Limit limit)`	Read messages from a stream within a specific `Range` applying a `Limit`.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xread(XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xread(XReadArgs args, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xreadgroup(Consumer<K> consumer, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s using a consumer group.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xreadgroup(Consumer<K> consumer, XReadArgs args, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s using a consumer group.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xrevrange(K key, Range<String> range)`	Read messages from a stream within a specific `Range` in reverse order.
`RedisFuture<List<StreamMessage<K,V>>>`	RedisStreamAsyncCommands.`xrevrange(K key, Range<String> range, Limit limit)`	Read messages from a stream within a specific `Range` applying a `Limit` in reverse order.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xtrim(K key, boolean approximateTrimming, long count)`	Trims the stream to `count` elements.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xtrim(K key, long count)`	Trims the stream to `count` elements.
`RedisFuture<Long>`	RedisStreamAsyncCommands.`xtrim(K key, XTrimArgs args)`	Trims the stream within a specific `XTrimArgs`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zadd(K key, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Double>`	RedisSortedSetAsyncCommands.`zaddincr(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`RedisFuture<Double>`	RedisSortedSetAsyncCommands.`zaddincr(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zcard(K key)`	Get the number of members in a sorted set.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zcount(K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zcount(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zcount(K key, Range<? extends Number> range)`	Count the members in a sorted set with scores within the given `Range`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zcount(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zcount(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zdiff(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zdiffstore(K destKey, K... srcKeys)`	Computes the difference between the first and all successive input sorted sets and stores the result in destination.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zdiffWithScores(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`RedisFuture<Double>`	RedisSortedSetAsyncCommands.`zincrby(K key, double amount, V member)`	Increment the score of a member in a sorted set.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zinter(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zinter(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zinterstore(K destination, ZStoreArgs storeArgs, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zinterstore(K destination, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zinterWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zinterWithScores(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zlexcount(K key, Range<? extends V> range)`	Count the number of members in a sorted set between a given lexicographical range.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zlexcount(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zlexcount(java.lang.Object, Range)`.
`RedisFuture<List<Double>>`	RedisSortedSetAsyncCommands.`zmscore(K key, V... members)`	Returns the scores associated with the specified members in the sorted set stored at key.
`RedisFuture<ScoredValue<V>>`	RedisSortedSetAsyncCommands.`zpopmax(K key)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zpopmax(K key, long count)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`RedisFuture<ScoredValue<V>>`	RedisSortedSetAsyncCommands.`zpopmin(K key)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zpopmin(K key, long count)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`RedisFuture<V>`	RedisSortedSetAsyncCommands.`zrandmember(K key)`	Return a random member from the sorted set stored at `key`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrandmember(K key, long count)`	Return `count` random members from the sorted set stored at `key`.
`RedisFuture<ScoredValue<V>>`	RedisSortedSetAsyncCommands.`zrandmemberWithScores(K key)`	Return a random member along its value from the sorted set stored at `key`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrandmemberWithScores(K key, long count)`	Return `count` random members along their value from the sorted set stored at `key`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebylex(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebylex(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebylex(K key, String min, String max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebylex(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, double min, double max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrangebyscore(K key, String min, String max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, double min, double max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangebyscoreWithScores(K key, String min, String max, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrank(K key, V member)`	Determine the index of a member in a sorted set.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrem(K key, V... members)`	Remove one or more members from a sorted set.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebylex(K key, Range<? extends V> range)`	Remove all members in a sorted set between the given lexicographical range.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebylex(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zremrangebylex(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebyrank(K key, long start, long stop)`	Remove all members in a sorted set within the given indexes.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebyscore(K key, double min, double max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zremrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebyscore(K key, Range<? extends Number> range)`	Remove all members in a sorted set within the given scores.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zremrangebyscore(K key, String min, String max)`	Deprecated. Use `RedisSortedSetAsyncCommands.zremrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, double max, double min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, double max, double min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, String max, String min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zrevrangebyscore(K key, String max, String min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, double max, double min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, String max, String min)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)`	Deprecated. Use `RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the lexicographical range ordered from high to low of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zrevrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zrevrank(K key, V member)`	Determine the index of a member in a sorted set, with scores ordered from high to low.
`RedisFuture<StreamScanCursor>`	RedisSortedSetAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	RedisSortedSetAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	RedisSortedSetAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	RedisSortedSetAsyncCommands.`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	RedisSortedSetAsyncCommands.`zscan(K key)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	RedisSortedSetAsyncCommands.`zscan(K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	RedisSortedSetAsyncCommands.`zscan(K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	RedisSortedSetAsyncCommands.`zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<Double>`	RedisSortedSetAsyncCommands.`zscore(K key, V member)`	Get the score associated with the given member in a sorted set.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zunion(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<List<V>>`	RedisSortedSetAsyncCommands.`zunion(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zunionstore(K destination, ZStoreArgs storeArgs, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	RedisSortedSetAsyncCommands.`zunionstore(K destination, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zunionWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<List<ScoredValue<V>>>`	RedisSortedSetAsyncCommands.`zunionWithScores(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.

Uses of RedisFuture in io.lettuce.core.cluster

Methods in io.lettuce.core.cluster that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`clientSetname(K name)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`clusterCountKeysInSlot(int slot)`
`RedisFuture<List<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`clusterGetKeysInSlot(int slot, int count)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`dbsize()`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`del(Iterable<K> keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`del(K... keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`exists(Iterable<K> keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`exists(K... keys)`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`flushall()`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`flushallAsync()`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`flushdb()`
`RedisFuture<Set<V>>`	RedisAdvancedClusterAsyncCommandsImpl.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	RedisAdvancedClusterAsyncCommandsImpl.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Set<V>>`	RedisClusterPubSubAsyncCommandsImpl.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	RedisClusterPubSubAsyncCommandsImpl.`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Set<V>>`	RedisAdvancedClusterAsyncCommandsImpl.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	RedisAdvancedClusterAsyncCommandsImpl.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Set<V>>`	RedisClusterPubSubAsyncCommandsImpl.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)`
`RedisFuture<List<GeoWithin<V>>>`	RedisClusterPubSubAsyncCommandsImpl.`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`keys(KeyStreamingChannel<K> channel, K pattern)`
`RedisFuture<List<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`keys(K pattern)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`mget(KeyValueStreamingChannel<K,V> channel, Iterable<K> keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`mget(KeyValueStreamingChannel<K,V> channel, K... keys)`
`RedisFuture<List<KeyValue<K,V>>>`	RedisAdvancedClusterAsyncCommandsImpl.`mget(Iterable<K> keys)`
`RedisFuture<List<KeyValue<K,V>>>`	RedisAdvancedClusterAsyncCommandsImpl.`mget(K... keys)`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`mset(Map<K,V> map)`
`RedisFuture<Boolean>`	RedisAdvancedClusterAsyncCommandsImpl.`msetnx(Map<K,V> map)`
`RedisFuture<K>`	RedisAdvancedClusterAsyncCommandsImpl.`randomkey()`
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`scan()`
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(KeyStreamingChannel<K> channel)`
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)`
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)`
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(ScanArgs scanArgs)`
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(ScanCursor scanCursor)`
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommandsImpl.`scan(ScanCursor scanCursor, ScanArgs scanArgs)`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`scriptFlush()`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`scriptKill()`
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommandsImpl.`scriptLoad(byte[] script)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`touch(Iterable<K> keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`touch(K... keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`unlink(Iterable<K> keys)`
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommandsImpl.`unlink(K... keys)`

Method parameters in io.lettuce.core.cluster with type arguments of type RedisFuture
Modifier and Type	Method	Description
`protected <T> Map<String,CompletableFuture<T>>`	RedisAdvancedClusterAsyncCommandsImpl.`executeOnNodes(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function, Function<RedisClusterNode,Boolean> filter)`	Run a command on all available nodes that match `filter`.
`protected <T> Map<String,CompletableFuture<T>>`	RedisAdvancedClusterAsyncCommandsImpl.`executeOnUpstream(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function)`	Run a command on all available masters,

Uses of RedisFuture in io.lettuce.core.cluster.api.async

Methods in io.lettuce.core.cluster.api.async that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<String>`	RedisClusterAsyncCommands.`asking()`	The asking command is required after a `-ASK` redirection.
`RedisFuture<String>`	RedisClusterAsyncCommands.`auth(CharSequence password)`	Authenticate to the server.
`RedisFuture<String>`	RedisClusterAsyncCommands.`auth(String username, CharSequence password)`	Authenticate to the server with username and password.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`clientSetname(K name)`	Set the current connection name on all cluster nodes with pipelining.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterAddSlots(int... slots)`	Adds slots to the cluster node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterBumpepoch()`	Generate a new config epoch, incrementing the current epoch, assign the new epoch to this node, WITHOUT any consensus and persist the configuration on disk before sending packets with the new configuration.
`RedisFuture<Long>`	RedisClusterAsyncCommands.`clusterCountFailureReports(String nodeId)`	Returns the number of failure reports for the specified node.
`RedisFuture<Long>`	RedisClusterAsyncCommands.`clusterCountKeysInSlot(int slot)`	Returns the number of keys in the specified Redis Cluster hash `slot`.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterDelSlots(int... slots)`	Removes slots from the cluster node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterFailover(boolean force)`	Failover a cluster node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterFlushslots()`	Delete all the slots associated with the specified node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterForget(String nodeId)`	Disallow connections and remove the cluster node from the cluster.
`RedisFuture<List<K>>`	RedisClusterAsyncCommands.`clusterGetKeysInSlot(int slot, int count)`	Retrieve the list of keys within the `slot`.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterInfo()`	Get information and statistics about the cluster viewed by the current node.
`RedisFuture<Long>`	RedisClusterAsyncCommands.`clusterKeyslot(K key)`	Returns an integer identifying the hash slot the specified key hashes to.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterMeet(String ip, int port)`	Meet another cluster node to include the node into the cluster.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterMyId()`	Obtain the nodeId for the currently connected node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterNodes()`	Obtain details about all cluster nodes.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterReplicate(String nodeId)`	Turn this node into a replica of the node with the id `nodeId`.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterReset(boolean hard)`	Reset a node performing a soft or hard reset: All other nodes are forgotten All the assigned / open slots are released If the node is a replica, it turns into a master Only for hard reset: a new Node ID is generated Only for hard reset: currentEpoch and configEpoch are set to 0 The new configuration is saved and the cluster state updated If the node was a replica, the whole data set is flushed away
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSaveconfig()`	Forces a node to save the nodes.conf configuration on disk.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSetConfigEpoch(long configEpoch)`	This command sets a specific config epoch in a fresh node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSetSlotImporting(int slot, String nodeId)`	Flag a slot as IMPORTING (incoming) from the node specified in `nodeId`.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSetSlotMigrating(int slot, String nodeId)`	Flag a slot as MIGRATING (outgoing) towards the node specified in `nodeId`.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSetSlotNode(int slot, String nodeId)`	Assign a slot to a node.
`RedisFuture<String>`	RedisClusterAsyncCommands.`clusterSetSlotStable(int slot)`	Clears migrating / importing state from the slot.
`RedisFuture<List<String>>`	RedisClusterAsyncCommands.`clusterSlaves(String nodeId)`	List replicas for a certain node identified by its `nodeId`.
`RedisFuture<List<Object>>`	RedisClusterAsyncCommands.`clusterSlots()`	Get array of cluster slots to node mappings.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`dbsize()`	Return the number of keys in the selected database on all cluster upstream nodes.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`del(K... keys)`	Delete one or more keys with pipelining.
`RedisFuture<Long>`	RedisClusterAsyncCommands.`del(K... keys)`	Delete a key with pipelining.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`exists(K... keys)`	Determine how many keys exist with pipelining.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`flushall()`	Remove all keys from all databases on all cluster upstream nodes with pipelining.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`flushallAsync()`	Remove all keys asynchronously from all databases on all cluster upstream nodes with pipelining.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`flushdb()`	Remove all keys from the current database on all cluster upstream nodes with pipelining.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`keys(KeyStreamingChannel<K> channel, K pattern)`	Find all keys matching the given pattern on all cluster upstream nodes.
`RedisFuture<List<K>>`	RedisAdvancedClusterAsyncCommands.`keys(K pattern)`	Find all keys matching the given pattern on all cluster upstream nodes.
`RedisFuture<List<KeyValue<K,V>>>`	RedisAdvancedClusterAsyncCommands.`mget(K... keys)`	Get the values of all the given keys with pipelining.
`RedisFuture<List<KeyValue<K,V>>>`	RedisClusterAsyncCommands.`mget(K... keys)`	Get the values of all the given keys with pipelining.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`mset(Map<K,V> map)`	Set multiple keys to multiple values with pipelining.
`RedisFuture<String>`	RedisClusterAsyncCommands.`mset(Map<K,V> map)`	Set multiple keys to multiple values with pipelining.
`RedisFuture<Boolean>`	RedisAdvancedClusterAsyncCommands.`msetnx(Map<K,V> map)`	Set multiple keys to multiple values, only if none of the keys exist with pipelining.
`RedisFuture<Boolean>`	RedisClusterAsyncCommands.`msetnx(Map<K,V> map)`	Set multiple keys to multiple values, only if none of the keys exist with pipelining.
`RedisFuture<K>`	RedisAdvancedClusterAsyncCommands.`randomkey()`	Return a random key from the keyspace on a random master.
`RedisFuture<String>`	RedisClusterAsyncCommands.`readOnly()`	Tells a Redis cluster replica node that the client is ok reading possibly stale data and is not interested in running write queries.
`RedisFuture<String>`	RedisClusterAsyncCommands.`readWrite()`	Resets readOnly flag.
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommands.`scan()`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommands.`scan(KeyStreamingChannel<K> channel)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<StreamScanCursor>`	RedisAdvancedClusterAsyncCommands.`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommands.`scan(ScanArgs scanArgs)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommands.`scan(ScanCursor scanCursor)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<KeyScanCursor<K>>`	RedisAdvancedClusterAsyncCommands.`scan(ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space over the whole Cluster.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`scriptFlush()`	Remove all the scripts from the script cache on all cluster nodes.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`scriptKill()`	Kill the script currently in execution on all cluster nodes.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`scriptLoad(byte[] script)`	Load the specified Lua script into the script cache on all cluster nodes.
`RedisFuture<String>`	RedisAdvancedClusterAsyncCommands.`scriptLoad(String script)`	Load the specified Lua script into the script cache on all cluster nodes.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`touch(K... keys)`	Touch one or more keys with pipelining.
`RedisFuture<Long>`	RedisAdvancedClusterAsyncCommands.`unlink(K... keys)`	Unlink one or more keys with pipelining.

Uses of RedisFuture in io.lettuce.core.internal

Methods in io.lettuce.core.internal with parameters of type RedisFuture
Modifier and Type	Method	Description
`static <T> T`	Futures.`awaitOrCancel(RedisFuture<T> cmd, long timeout, TimeUnit unit)`	Wait until futures are complete or the supplied timeout is reached.

Uses of RedisFuture in io.lettuce.core.protocol

Classes in io.lettuce.core.protocol that implement RedisFuture
Modifier and Type	Class	Description
`class`	`AsyncCommand<K,V,T>`	An asynchronous redis command and its result.
`class`	`TransactionalCommand<K,V,T>`	A wrapper for commands within a MULTI transaction.

Uses of RedisFuture in io.lettuce.core.pubsub

Methods in io.lettuce.core.pubsub that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<Void>`	RedisPubSubAsyncCommandsImpl.`psubscribe(K... patterns)`
`RedisFuture<Long>`	RedisPubSubAsyncCommandsImpl.`publish(K channel, V message)`
`RedisFuture<List<K>>`	RedisPubSubAsyncCommandsImpl.`pubsubChannels(K channel)`
`RedisFuture<Map<K,Long>>`	RedisPubSubAsyncCommandsImpl.`pubsubNumsub(K... channels)`
`RedisFuture<Void>`	RedisPubSubAsyncCommandsImpl.`punsubscribe(K... patterns)`
`RedisFuture<Void>`	RedisPubSubAsyncCommandsImpl.`subscribe(K... channels)`
`RedisFuture<Void>`	RedisPubSubAsyncCommandsImpl.`unsubscribe(K... channels)`

Methods in io.lettuce.core.pubsub that return types with arguments of type RedisFuture
Modifier and Type	Method	Description
`protected List<RedisFuture<Void>>`	StatefulRedisPubSubConnectionImpl.`resubscribe()`	Re-subscribe to all previously subscribed channels and patterns.

Uses of RedisFuture in io.lettuce.core.pubsub.api.async

Methods in io.lettuce.core.pubsub.api.async that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<Void>`	RedisPubSubAsyncCommands.`psubscribe(K... patterns)`	Listen for messages published to channels matching the given patterns.
`RedisFuture<Void>`	RedisPubSubAsyncCommands.`punsubscribe(K... patterns)`	Stop listening for messages posted to channels matching the given patterns.
`RedisFuture<Void>`	RedisPubSubAsyncCommands.`subscribe(K... channels)`	Listen for messages published to the given channels.
`RedisFuture<Void>`	RedisPubSubAsyncCommands.`unsubscribe(K... channels)`	Stop listening for messages posted to the given channels.

Uses of RedisFuture in io.lettuce.core.sentinel

Methods in io.lettuce.core.sentinel that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<K>`	RedisSentinelAsyncCommandsImpl.`clientGetname()`
`RedisFuture<Long>`	RedisSentinelAsyncCommandsImpl.`clientKill(KillArgs killArgs)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`clientKill(String addr)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`clientList()`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`clientPause(long timeout)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`clientSetname(K name)`
`<T> RedisFuture<T>`	RedisSentinelAsyncCommandsImpl.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output)`
`<T> RedisFuture<T>`	RedisSentinelAsyncCommandsImpl.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`failover(K key)`
`RedisFuture<SocketAddress>`	RedisSentinelAsyncCommandsImpl.`getMasterAddrByName(K key)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`info()`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`info(String section)`
`RedisFuture<Map<K,V>>`	RedisSentinelAsyncCommandsImpl.`master(K key)`
`RedisFuture<List<Map<K,V>>>`	RedisSentinelAsyncCommandsImpl.`masters()`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`monitor(K key, String ip, int port, int quorum)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`ping()`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`remove(K key)`
`RedisFuture<Long>`	RedisSentinelAsyncCommandsImpl.`reset(K key)`
`RedisFuture<String>`	RedisSentinelAsyncCommandsImpl.`set(K key, String option, V value)`
`RedisFuture<List<Map<K,V>>>`	RedisSentinelAsyncCommandsImpl.`slaves(K key)`

Uses of RedisFuture in io.lettuce.core.sentinel.api.async

Methods in io.lettuce.core.sentinel.api.async that return RedisFuture
Modifier and Type	Method	Description
`RedisFuture<K>`	RedisSentinelAsyncCommands.`clientGetname()`	Get the current connection name.
`RedisFuture<Long>`	RedisSentinelAsyncCommands.`clientKill(KillArgs killArgs)`	Kill connections of clients which are filtered by `killArgs`.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`clientKill(String addr)`	Kill the connection of a client identified by ip:port.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`clientList()`	Get the list of client connections.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`clientPause(long timeout)`	Stop processing commands from clients for some time.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`clientSetname(K name)`	Set the current connection name.
`<T> RedisFuture<T>`	RedisSentinelAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output)`	Dispatch a command to the Redis Server.
`<T> RedisFuture<T>`	RedisSentinelAsyncCommands.`dispatch(ProtocolKeyword type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`	Dispatch a command to the Redis Server.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`failover(K key)`	Perform a failover.
`RedisFuture<SocketAddress>`	RedisSentinelAsyncCommands.`getMasterAddrByName(K key)`	Return the ip and port number of the master with that name.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`info()`	Get information and statistics about the server.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`info(String section)`	Get information and statistics about the server.
`RedisFuture<Map<K,V>>`	RedisSentinelAsyncCommands.`master(K key)`	Show the state and info of the specified master.
`RedisFuture<List<Map<K,V>>>`	RedisSentinelAsyncCommands.`masters()`	Enumerates all the monitored masters and their states.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`monitor(K key, String ip, int port, int quorum)`	This command tells the Sentinel to start monitoring a new master with the specified name, ip, port, and quorum.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`ping()`	Ping the server.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`remove(K key)`	remove the specified master.
`RedisFuture<Long>`	RedisSentinelAsyncCommands.`reset(K key)`	This command will reset all the masters with matching name.
`RedisFuture<String>`	RedisSentinelAsyncCommands.`set(K key, String option, V value)`	Multiple option / value pairs can be specified (or none at all).
`RedisFuture<List<Map<K,V>>>`	RedisSentinelAsyncCommands.`slaves(K key)`	Provides a list of replicas for the master with the specified name.

Uses of Interfaceio.lettuce.core.RedisFuture

Uses of RedisFuture in io.lettuce.core

Uses of RedisFuture in io.lettuce.core.api.async

Uses of RedisFuture in io.lettuce.core.cluster

Uses of RedisFuture in io.lettuce.core.cluster.api.async

Uses of RedisFuture in io.lettuce.core.internal

Uses of RedisFuture in io.lettuce.core.protocol

Uses of RedisFuture in io.lettuce.core.pubsub

Uses of RedisFuture in io.lettuce.core.pubsub.api.async

Uses of RedisFuture in io.lettuce.core.sentinel

Uses of RedisFuture in io.lettuce.core.sentinel.api.async

Uses of Interface
io.lettuce.core.RedisFuture