cmd.go

// Generated by gen.bash.
// DO NOT EDIT THIS FILE DIRECTLY!

package rediscluster

import (
	"github.com/fzzbt/radix/redis"
)

const (
	cmdAppend           string = "APPEND"
	cmdAsking           string = "ASKING"
	cmdAuth             string = "AUTH"
	cmdBgrewriteaof     string = "BGREWRITEAOF"
	cmdBgsave           string = "BGSAVE"
	cmdBitcount         string = "BITCOUNT"
	cmdBitop            string = "BITOP"
	cmdBlpop            string = "BLPOP"
	cmdBrpop            string = "BRPOP"
	cmdBrpoplpush       string = "BRPOPLPUSH"
	cmdClient           string = "CLIENT"
	cmdCluster          string = "CLUSTER"
	cmdConfig           string = "CONFIG"
	cmdDbsize           string = "DBSIZE"
	cmdDebug            string = "DEBUG"
	cmdDecr             string = "DECR"
	cmdDecrby           string = "DECRBY"
	cmdDel              string = "DEL"
	cmdDiscard          string = "DISCARD"
	cmdDump             string = "DUMP"
	cmdEcho             string = "ECHO"
	cmdEval             string = "EVAL"
	cmdExec             string = "EXEC"
	cmdExists           string = "EXISTS"
	cmdExpire           string = "EXPIRE"
	cmdExpireat         string = "EXPIREAT"
	cmdFlushall         string = "FLUSHALL"
	cmdFlushdb          string = "FLUSHDB"
	cmdGet              string = "GET"
	cmdGetbit           string = "GETBIT"
	cmdGetrange         string = "GETRANGE"
	cmdGetset           string = "GETSET"
	cmdHdel             string = "HDEL"
	cmdHexists          string = "HEXISTS"
	cmdHget             string = "HGET"
	cmdHgetall          string = "HGETALL"
	cmdHincrby          string = "HINCRBY"
	cmdHincrbyfloat     string = "HINCRBYFLOAT"
	cmdHkeys            string = "HKEYS"
	cmdHlen             string = "HLEN"
	cmdHmget            string = "HMGET"
	cmdHmset            string = "HMSET"
	cmdHset             string = "HSET"
	cmdHsetnx           string = "HSETNX"
	cmdHvals            string = "HVALS"
	cmdIncr             string = "INCR"
	cmdIncrby           string = "INCRBY"
	cmdIncrbyfloat      string = "INCRBYFLOAT"
	cmdInfo             string = "INFO"
	cmdKeys             string = "KEYS"
	cmdLastsave         string = "LASTSAVE"
	cmdLindex           string = "LINDEX"
	cmdLinsert          string = "LINSERT"
	cmdLlen             string = "LLEN"
	cmdLpop             string = "LPOP"
	cmdLpush            string = "LPUSH"
	cmdLpushx           string = "LPUSHX"
	cmdLrange           string = "LRANGE"
	cmdLrem             string = "LREM"
	cmdLset             string = "LSET"
	cmdLtrim            string = "LTRIM"
	cmdMget             string = "MGET"
	cmdMigrate          string = "MIGRATE"
	cmdMonitor          string = "MONITOR"
	cmdMove             string = "MOVE"
	cmdMset             string = "MSET"
	cmdMsetnx           string = "MSETNX"
	cmdMulti            string = "MULTI"
	cmdObject           string = "OBJECT"
	cmdPersist          string = "PERSIST"
	cmdPexpire          string = "PEXPIRE"
	cmdPexpireat        string = "PEXPIREAT"
	cmdPing             string = "PING"
	cmdPsetex           string = "PSETEX"
	cmdPsubscribe       string = "PSUBSCRIBE"
	cmdPttl             string = "PTTL"
	cmdPublish          string = "PUBLISH"
	cmdPunsubscribe     string = "PUNSUBSCRIBE"
	cmdRandomkey        string = "RANDOMKEY"
	cmdRename           string = "RENAME"
	cmdRenamenx         string = "RENAMENX"
	cmdReplconf         string = "REPLCONF"
	cmdRestore          string = "RESTORE"
	cmdRpop             string = "RPOP"
	cmdRpoplpush        string = "RPOPLPUSH"
	cmdRpush            string = "RPUSH"
	cmdRpushx           string = "RPUSHX"
	cmdSadd             string = "SADD"
	cmdSave             string = "SAVE"
	cmdScard            string = "SCARD"
	cmdScript           string = "SCRIPT"
	cmdSdiff            string = "SDIFF"
	cmdSdiffstore       string = "SDIFFSTORE"
	cmdSelect           string = "SELECT"
	cmdSet              string = "SET"
	cmdSetbit           string = "SETBIT"
	cmdSetex            string = "SETEX"
	cmdSetnx            string = "SETNX"
	cmdSetrange         string = "SETRANGE"
	cmdShutdown         string = "SHUTDOWN"
	cmdSinter           string = "SINTER"
	cmdSinterstore      string = "SINTERSTORE"
	cmdSismember        string = "SISMEMBER"
	cmdSlaveof          string = "SLAVEOF"
	cmdSmembers         string = "SMEMBERS"
	cmdSmove            string = "SMOVE"
	cmdSort             string = "SORT"
	cmdSpop             string = "SPOP"
	cmdSrandmember      string = "SRANDMEMBER"
	cmdSrem             string = "SREM"
	cmdStrlen           string = "STRLEN"
	cmdSubscribe        string = "SUBSCRIBE"
	cmdSunion           string = "SUNION"
	cmdSunionstore      string = "SUNIONSTORE"
	cmdSync             string = "SYNC"
	cmdTime             string = "TIME"
	cmdTtl              string = "TTL"
	cmdType             string = "TYPE"
	cmdUnsubscribe      string = "UNSUBSCRIBE"
	cmdUnwatch          string = "UNWATCH"
	cmdWatch            string = "WATCH"
	cmdZadd             string = "ZADD"
	cmdZcard            string = "ZCARD"
	cmdZcount           string = "ZCOUNT"
	cmdZincrby          string = "ZINCRBY"
	cmdZinterstore      string = "ZINTERSTORE"
	cmdZrange           string = "ZRANGE"
	cmdZrangebyscore    string = "ZRANGEBYSCORE"
	cmdZrank            string = "ZRANK"
	cmdZrem             string = "ZREM"
	cmdZremrangebyrank  string = "ZREMRANGEBYRANK"
	cmdZremrangebyscore string = "ZREMRANGEBYSCORE"
	cmdZrevrange        string = "ZREVRANGE"
	cmdZrevrangebyscore string = "ZREVRANGEBYSCORE"
	cmdZrevrank         string = "ZREVRANK"
	cmdZscore           string = "ZSCORE"
	cmdZunionstore      string = "ZUNIONSTORE"
)

// Append calls Redis APPEND command. 
func (cc *Cluster) Append(args ...interface{}) *redis.Reply {
	return cc.Call(cmdAppend, args...)
}

// Asking calls Redis ASKING command. 
func (cc *Cluster) Asking(args ...interface{}) *redis.Reply {
	return cc.Call(cmdAsking, args...)
}

// Auth calls Redis AUTH command. 
func (cc *Cluster) Auth(args ...interface{}) *redis.Reply {
	return cc.Call(cmdAuth, args...)
}

// Bgrewriteaof calls Redis BGREWRITEAOF command. 
func (cc *Cluster) Bgrewriteaof(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBgrewriteaof, args...)
}

// Bgsave calls Redis BGSAVE command. 
func (cc *Cluster) Bgsave(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBgsave, args...)
}

// Bitcount calls Redis BITCOUNT command. 
func (cc *Cluster) Bitcount(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBitcount, args...)
}

// Bitop calls Redis BITOP command. 
func (cc *Cluster) Bitop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBitop, args...)
}

// Blpop calls Redis BLPOP command. 
func (cc *Cluster) Blpop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBlpop, args...)
}

// Brpop calls Redis BRPOP command. 
func (cc *Cluster) Brpop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBrpop, args...)
}

// Brpoplpush calls Redis BRPOPLPUSH command. 
func (cc *Cluster) Brpoplpush(args ...interface{}) *redis.Reply {
	return cc.Call(cmdBrpoplpush, args...)
}

// Client calls Redis CLIENT command. 
func (cc *Cluster) Client(args ...interface{}) *redis.Reply {
	return cc.Call(cmdClient, args...)
}

// Cluster calls Redis CLUSTER command. 
func (cc *Cluster) Cluster(args ...interface{}) *redis.Reply {
	return cc.Call(cmdCluster, args...)
}

// Config calls Redis CONFIG command. 
func (cc *Cluster) Config(args ...interface{}) *redis.Reply {
	return cc.Call(cmdConfig, args...)
}

// Dbsize calls Redis DBSIZE command. 
func (cc *Cluster) Dbsize(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDbsize, args...)
}

// Debug calls Redis DEBUG command. 
func (cc *Cluster) Debug(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDebug, args...)
}

// Decr calls Redis DECR command. 
func (cc *Cluster) Decr(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDecr, args...)
}

// Decrby calls Redis DECRBY command. 
func (cc *Cluster) Decrby(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDecrby, args...)
}

// Del calls Redis DEL command. 
func (cc *Cluster) Del(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDel, args...)
}

// Discard calls Redis DISCARD command. 
func (cc *Cluster) Discard(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDiscard, args...)
}

// Dump calls Redis DUMP command. 
func (cc *Cluster) Dump(args ...interface{}) *redis.Reply {
	return cc.Call(cmdDump, args...)
}

// Echo calls Redis ECHO command. 
func (cc *Cluster) Echo(args ...interface{}) *redis.Reply {
	return cc.Call(cmdEcho, args...)
}

// Eval calls Redis EVAL command. 
func (cc *Cluster) Eval(args ...interface{}) *redis.Reply {
	return cc.Call(cmdEval, args...)
}

// Exec calls Redis EXEC command. 
func (cc *Cluster) Exec(args ...interface{}) *redis.Reply {
	return cc.Call(cmdExec, args...)
}

// Exists calls Redis EXISTS command. 
func (cc *Cluster) Exists(args ...interface{}) *redis.Reply {
	return cc.Call(cmdExists, args...)
}

// Expire calls Redis EXPIRE command. 
func (cc *Cluster) Expire(args ...interface{}) *redis.Reply {
	return cc.Call(cmdExpire, args...)
}

// Expireat calls Redis EXPIREAT command. 
func (cc *Cluster) Expireat(args ...interface{}) *redis.Reply {
	return cc.Call(cmdExpireat, args...)
}

// Flushall calls Redis FLUSHALL command. 
func (cc *Cluster) Flushall(args ...interface{}) *redis.Reply {
	return cc.Call(cmdFlushall, args...)
}

// Flushdb calls Redis FLUSHDB command. 
func (cc *Cluster) Flushdb(args ...interface{}) *redis.Reply {
	return cc.Call(cmdFlushdb, args...)
}

// Get calls Redis GET command. 
func (cc *Cluster) Get(args ...interface{}) *redis.Reply {
	return cc.Call(cmdGet, args...)
}

// Getbit calls Redis GETBIT command. 
func (cc *Cluster) Getbit(args ...interface{}) *redis.Reply {
	return cc.Call(cmdGetbit, args...)
}

// Getrange calls Redis GETRANGE command. 
func (cc *Cluster) Getrange(args ...interface{}) *redis.Reply {
	return cc.Call(cmdGetrange, args...)
}

// Getset calls Redis GETSET command. 
func (cc *Cluster) Getset(args ...interface{}) *redis.Reply {
	return cc.Call(cmdGetset, args...)
}

// Hdel calls Redis HDEL command. 
func (cc *Cluster) Hdel(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHdel, args...)
}

// Hexists calls Redis HEXISTS command. 
func (cc *Cluster) Hexists(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHexists, args...)
}

// Hget calls Redis HGET command. 
func (cc *Cluster) Hget(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHget, args...)
}

// Hgetall calls Redis HGETALL command. 
func (cc *Cluster) Hgetall(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHgetall, args...)
}

// Hincrby calls Redis HINCRBY command. 
func (cc *Cluster) Hincrby(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHincrby, args...)
}

// Hincrbyfloat calls Redis HINCRBYFLOAT command. 
func (cc *Cluster) Hincrbyfloat(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHincrbyfloat, args...)
}

// Hkeys calls Redis HKEYS command. 
func (cc *Cluster) Hkeys(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHkeys, args...)
}

// Hlen calls Redis HLEN command. 
func (cc *Cluster) Hlen(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHlen, args...)
}

// Hmget calls Redis HMGET command. 
func (cc *Cluster) Hmget(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHmget, args...)
}

// Hmset calls Redis HMSET command. 
func (cc *Cluster) Hmset(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHmset, args...)
}

// Hset calls Redis HSET command. 
func (cc *Cluster) Hset(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHset, args...)
}

// Hsetnx calls Redis HSETNX command. 
func (cc *Cluster) Hsetnx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHsetnx, args...)
}

// Hvals calls Redis HVALS command. 
func (cc *Cluster) Hvals(args ...interface{}) *redis.Reply {
	return cc.Call(cmdHvals, args...)
}

// Incr calls Redis INCR command. 
func (cc *Cluster) Incr(args ...interface{}) *redis.Reply {
	return cc.Call(cmdIncr, args...)
}

// Incrby calls Redis INCRBY command. 
func (cc *Cluster) Incrby(args ...interface{}) *redis.Reply {
	return cc.Call(cmdIncrby, args...)
}

// Incrbyfloat calls Redis INCRBYFLOAT command. 
func (cc *Cluster) Incrbyfloat(args ...interface{}) *redis.Reply {
	return cc.Call(cmdIncrbyfloat, args...)
}

// Info calls Redis INFO command. 
func (cc *Cluster) Info(args ...interface{}) *redis.Reply {
	return cc.Call(cmdInfo, args...)
}

// Keys calls Redis KEYS command. 
func (cc *Cluster) Keys(args ...interface{}) *redis.Reply {
	return cc.Call(cmdKeys, args...)
}

// Lastsave calls Redis LASTSAVE command. 
func (cc *Cluster) Lastsave(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLastsave, args...)
}

// Lindex calls Redis LINDEX command. 
func (cc *Cluster) Lindex(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLindex, args...)
}

// Linsert calls Redis LINSERT command. 
func (cc *Cluster) Linsert(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLinsert, args...)
}

// Llen calls Redis LLEN command. 
func (cc *Cluster) Llen(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLlen, args...)
}

// Lpop calls Redis LPOP command. 
func (cc *Cluster) Lpop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLpop, args...)
}

// Lpush calls Redis LPUSH command. 
func (cc *Cluster) Lpush(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLpush, args...)
}

// Lpushx calls Redis LPUSHX command. 
func (cc *Cluster) Lpushx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLpushx, args...)
}

// Lrange calls Redis LRANGE command. 
func (cc *Cluster) Lrange(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLrange, args...)
}

// Lrem calls Redis LREM command. 
func (cc *Cluster) Lrem(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLrem, args...)
}

// Lset calls Redis LSET command. 
func (cc *Cluster) Lset(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLset, args...)
}

// Ltrim calls Redis LTRIM command. 
func (cc *Cluster) Ltrim(args ...interface{}) *redis.Reply {
	return cc.Call(cmdLtrim, args...)
}

// Mget calls Redis MGET command. 
func (cc *Cluster) Mget(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMget, args...)
}

// Migrate calls Redis MIGRATE command. 
func (cc *Cluster) Migrate(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMigrate, args...)
}

// Monitor calls Redis MONITOR command. 
func (cc *Cluster) Monitor(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMonitor, args...)
}

// Move calls Redis MOVE command. 
func (cc *Cluster) Move(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMove, args...)
}

// Mset calls Redis MSET command. 
func (cc *Cluster) Mset(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMset, args...)
}

// Msetnx calls Redis MSETNX command. 
func (cc *Cluster) Msetnx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMsetnx, args...)
}

// Multi calls Redis MULTI command. 
func (cc *Cluster) Multi(args ...interface{}) *redis.Reply {
	return cc.Call(cmdMulti, args...)
}

// Object calls Redis OBJECT command. 
func (cc *Cluster) Object(args ...interface{}) *redis.Reply {
	return cc.Call(cmdObject, args...)
}

// Persist calls Redis PERSIST command. 
func (cc *Cluster) Persist(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPersist, args...)
}

// Pexpire calls Redis PEXPIRE command. 
func (cc *Cluster) Pexpire(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPexpire, args...)
}

// Pexpireat calls Redis PEXPIREAT command. 
func (cc *Cluster) Pexpireat(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPexpireat, args...)
}

// Ping calls Redis PING command. 
func (cc *Cluster) Ping(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPing, args...)
}

// Psetex calls Redis PSETEX command. 
func (cc *Cluster) Psetex(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPsetex, args...)
}

// Psubscribe calls Redis PSUBSCRIBE command. 
func (cc *Cluster) Psubscribe(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPsubscribe, args...)
}

// Pttl calls Redis PTTL command. 
func (cc *Cluster) Pttl(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPttl, args...)
}

// Publish calls Redis PUBLISH command. 
func (cc *Cluster) Publish(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPublish, args...)
}

// Punsubscribe calls Redis PUNSUBSCRIBE command. 
func (cc *Cluster) Punsubscribe(args ...interface{}) *redis.Reply {
	return cc.Call(cmdPunsubscribe, args...)
}

// Randomkey calls Redis RANDOMKEY command. 
func (cc *Cluster) Randomkey(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRandomkey, args...)
}

// Rename calls Redis RENAME command. 
func (cc *Cluster) Rename(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRename, args...)
}

// Renamenx calls Redis RENAMENX command. 
func (cc *Cluster) Renamenx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRenamenx, args...)
}

// Replconf calls Redis REPLCONF command. 
func (cc *Cluster) Replconf(args ...interface{}) *redis.Reply {
	return cc.Call(cmdReplconf, args...)
}

// Restore calls Redis RESTORE command. 
func (cc *Cluster) Restore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRestore, args...)
}

// Rpop calls Redis RPOP command. 
func (cc *Cluster) Rpop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRpop, args...)
}

// Rpoplpush calls Redis RPOPLPUSH command. 
func (cc *Cluster) Rpoplpush(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRpoplpush, args...)
}

// Rpush calls Redis RPUSH command. 
func (cc *Cluster) Rpush(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRpush, args...)
}

// Rpushx calls Redis RPUSHX command. 
func (cc *Cluster) Rpushx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdRpushx, args...)
}

// Sadd calls Redis SADD command. 
func (cc *Cluster) Sadd(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSadd, args...)
}

// Save calls Redis SAVE command. 
func (cc *Cluster) Save(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSave, args...)
}

// Scard calls Redis SCARD command. 
func (cc *Cluster) Scard(args ...interface{}) *redis.Reply {
	return cc.Call(cmdScard, args...)
}

// Script calls Redis SCRIPT command. 
func (cc *Cluster) Script(args ...interface{}) *redis.Reply {
	return cc.Call(cmdScript, args...)
}

// Sdiff calls Redis SDIFF command. 
func (cc *Cluster) Sdiff(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSdiff, args...)
}

// Sdiffstore calls Redis SDIFFSTORE command. 
func (cc *Cluster) Sdiffstore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSdiffstore, args...)
}

// Select calls Redis SELECT command. 
func (cc *Cluster) Select(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSelect, args...)
}

// Set calls Redis SET command. 
func (cc *Cluster) Set(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSet, args...)
}

// Setbit calls Redis SETBIT command. 
func (cc *Cluster) Setbit(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSetbit, args...)
}

// Setex calls Redis SETEX command. 
func (cc *Cluster) Setex(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSetex, args...)
}

// Setnx calls Redis SETNX command. 
func (cc *Cluster) Setnx(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSetnx, args...)
}

// Setrange calls Redis SETRANGE command. 
func (cc *Cluster) Setrange(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSetrange, args...)
}

// Shutdown calls Redis SHUTDOWN command. 
func (cc *Cluster) Shutdown(args ...interface{}) *redis.Reply {
	return cc.Call(cmdShutdown, args...)
}

// Sinter calls Redis SINTER command. 
func (cc *Cluster) Sinter(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSinter, args...)
}

// Sinterstore calls Redis SINTERSTORE command. 
func (cc *Cluster) Sinterstore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSinterstore, args...)
}

// Sismember calls Redis SISMEMBER command. 
func (cc *Cluster) Sismember(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSismember, args...)
}

// Slaveof calls Redis SLAVEOF command. 
func (cc *Cluster) Slaveof(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSlaveof, args...)
}

// Smembers calls Redis SMEMBERS command. 
func (cc *Cluster) Smembers(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSmembers, args...)
}

// Smove calls Redis SMOVE command. 
func (cc *Cluster) Smove(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSmove, args...)
}

// Sort calls Redis SORT command. 
func (cc *Cluster) Sort(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSort, args...)
}

// Spop calls Redis SPOP command. 
func (cc *Cluster) Spop(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSpop, args...)
}

// Srandmember calls Redis SRANDMEMBER command. 
func (cc *Cluster) Srandmember(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSrandmember, args...)
}

// Srem calls Redis SREM command. 
func (cc *Cluster) Srem(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSrem, args...)
}

// Strlen calls Redis STRLEN command. 
func (cc *Cluster) Strlen(args ...interface{}) *redis.Reply {
	return cc.Call(cmdStrlen, args...)
}

// Subscribe calls Redis SUBSCRIBE command. 
func (cc *Cluster) Subscribe(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSubscribe, args...)
}

// Sunion calls Redis SUNION command. 
func (cc *Cluster) Sunion(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSunion, args...)
}

// Sunionstore calls Redis SUNIONSTORE command. 
func (cc *Cluster) Sunionstore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSunionstore, args...)
}

// Sync calls Redis SYNC command. 
func (cc *Cluster) Sync(args ...interface{}) *redis.Reply {
	return cc.Call(cmdSync, args...)
}

// Time calls Redis TIME command. 
func (cc *Cluster) Time(args ...interface{}) *redis.Reply {
	return cc.Call(cmdTime, args...)
}

// Ttl calls Redis TTL command. 
func (cc *Cluster) Ttl(args ...interface{}) *redis.Reply {
	return cc.Call(cmdTtl, args...)
}

// Type calls Redis TYPE command. 
func (cc *Cluster) Type(args ...interface{}) *redis.Reply {
	return cc.Call(cmdType, args...)
}

// Unsubscribe calls Redis UNSUBSCRIBE command. 
func (cc *Cluster) Unsubscribe(args ...interface{}) *redis.Reply {
	return cc.Call(cmdUnsubscribe, args...)
}

// Unwatch calls Redis UNWATCH command. 
func (cc *Cluster) Unwatch(args ...interface{}) *redis.Reply {
	return cc.Call(cmdUnwatch, args...)
}

// Watch calls Redis WATCH command. 
func (cc *Cluster) Watch(args ...interface{}) *redis.Reply {
	return cc.Call(cmdWatch, args...)
}

// Zadd calls Redis ZADD command. 
func (cc *Cluster) Zadd(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZadd, args...)
}

// Zcard calls Redis ZCARD command. 
func (cc *Cluster) Zcard(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZcard, args...)
}

// Zcount calls Redis ZCOUNT command. 
func (cc *Cluster) Zcount(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZcount, args...)
}

// Zincrby calls Redis ZINCRBY command. 
func (cc *Cluster) Zincrby(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZincrby, args...)
}

// Zinterstore calls Redis ZINTERSTORE command. 
func (cc *Cluster) Zinterstore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZinterstore, args...)
}

// Zrange calls Redis ZRANGE command. 
func (cc *Cluster) Zrange(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrange, args...)
}

// Zrangebyscore calls Redis ZRANGEBYSCORE command. 
func (cc *Cluster) Zrangebyscore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrangebyscore, args...)
}

// Zrank calls Redis ZRANK command. 
func (cc *Cluster) Zrank(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrank, args...)
}

// Zrem calls Redis ZREM command. 
func (cc *Cluster) Zrem(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrem, args...)
}

// Zremrangebyrank calls Redis ZREMRANGEBYRANK command. 
func (cc *Cluster) Zremrangebyrank(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZremrangebyrank, args...)
}

// Zremrangebyscore calls Redis ZREMRANGEBYSCORE command. 
func (cc *Cluster) Zremrangebyscore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZremrangebyscore, args...)
}

// Zrevrange calls Redis ZREVRANGE command. 
func (cc *Cluster) Zrevrange(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrevrange, args...)
}

// Zrevrangebyscore calls Redis ZREVRANGEBYSCORE command. 
func (cc *Cluster) Zrevrangebyscore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrevrangebyscore, args...)
}

// Zrevrank calls Redis ZREVRANK command. 
func (cc *Cluster) Zrevrank(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZrevrank, args...)
}

// Zscore calls Redis ZSCORE command. 
func (cc *Cluster) Zscore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZscore, args...)
}

// Zunionstore calls Redis ZUNIONSTORE command. 
func (cc *Cluster) Zunionstore(args ...interface{}) *redis.Reply {
	return cc.Call(cmdZunionstore, args...)
}

// AsyncAppend calls Redis APPEND asynchronously. 
func (cc *Cluster) AsyncAppend(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdAppend, args...)
}

// AsyncAsking calls Redis ASKING asynchronously. 
func (cc *Cluster) AsyncAsking(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdAsking, args...)
}

// AsyncAuth calls Redis AUTH asynchronously. 
func (cc *Cluster) AsyncAuth(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdAuth, args...)
}

// AsyncBgrewriteaof calls Redis BGREWRITEAOF asynchronously. 
func (cc *Cluster) AsyncBgrewriteaof(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBgrewriteaof, args...)
}

// AsyncBgsave calls Redis BGSAVE asynchronously. 
func (cc *Cluster) AsyncBgsave(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBgsave, args...)
}

// AsyncBitcount calls Redis BITCOUNT asynchronously. 
func (cc *Cluster) AsyncBitcount(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBitcount, args...)
}

// AsyncBitop calls Redis BITOP asynchronously. 
func (cc *Cluster) AsyncBitop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBitop, args...)
}

// AsyncBlpop calls Redis BLPOP asynchronously. 
func (cc *Cluster) AsyncBlpop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBlpop, args...)
}

// AsyncBrpop calls Redis BRPOP asynchronously. 
func (cc *Cluster) AsyncBrpop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBrpop, args...)
}

// AsyncBrpoplpush calls Redis BRPOPLPUSH asynchronously. 
func (cc *Cluster) AsyncBrpoplpush(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdBrpoplpush, args...)
}

// AsyncClient calls Redis CLIENT asynchronously. 
func (cc *Cluster) AsyncClient(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdClient, args...)
}

// AsyncCluster calls Redis CLUSTER asynchronously. 
func (cc *Cluster) AsyncCluster(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdCluster, args...)
}

// AsyncConfig calls Redis CONFIG asynchronously. 
func (cc *Cluster) AsyncConfig(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdConfig, args...)
}

// AsyncDbsize calls Redis DBSIZE asynchronously. 
func (cc *Cluster) AsyncDbsize(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDbsize, args...)
}

// AsyncDebug calls Redis DEBUG asynchronously. 
func (cc *Cluster) AsyncDebug(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDebug, args...)
}

// AsyncDecr calls Redis DECR asynchronously. 
func (cc *Cluster) AsyncDecr(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDecr, args...)
}

// AsyncDecrby calls Redis DECRBY asynchronously. 
func (cc *Cluster) AsyncDecrby(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDecrby, args...)
}

// AsyncDel calls Redis DEL asynchronously. 
func (cc *Cluster) AsyncDel(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDel, args...)
}

// AsyncDiscard calls Redis DISCARD asynchronously. 
func (cc *Cluster) AsyncDiscard(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDiscard, args...)
}

// AsyncDump calls Redis DUMP asynchronously. 
func (cc *Cluster) AsyncDump(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdDump, args...)
}

// AsyncEcho calls Redis ECHO asynchronously. 
func (cc *Cluster) AsyncEcho(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdEcho, args...)
}

// AsyncEval calls Redis EVAL asynchronously. 
func (cc *Cluster) AsyncEval(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdEval, args...)
}

// AsyncExec calls Redis EXEC asynchronously. 
func (cc *Cluster) AsyncExec(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdExec, args...)
}

// AsyncExists calls Redis EXISTS asynchronously. 
func (cc *Cluster) AsyncExists(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdExists, args...)
}

// AsyncExpire calls Redis EXPIRE asynchronously. 
func (cc *Cluster) AsyncExpire(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdExpire, args...)
}

// AsyncExpireat calls Redis EXPIREAT asynchronously. 
func (cc *Cluster) AsyncExpireat(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdExpireat, args...)
}

// AsyncFlushall calls Redis FLUSHALL asynchronously. 
func (cc *Cluster) AsyncFlushall(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdFlushall, args...)
}

// AsyncFlushdb calls Redis FLUSHDB asynchronously. 
func (cc *Cluster) AsyncFlushdb(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdFlushdb, args...)
}

// AsyncGet calls Redis GET asynchronously. 
func (cc *Cluster) AsyncGet(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdGet, args...)
}

// AsyncGetbit calls Redis GETBIT asynchronously. 
func (cc *Cluster) AsyncGetbit(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdGetbit, args...)
}

// AsyncGetrange calls Redis GETRANGE asynchronously. 
func (cc *Cluster) AsyncGetrange(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdGetrange, args...)
}

// AsyncGetset calls Redis GETSET asynchronously. 
func (cc *Cluster) AsyncGetset(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdGetset, args...)
}

// AsyncHdel calls Redis HDEL asynchronously. 
func (cc *Cluster) AsyncHdel(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHdel, args...)
}

// AsyncHexists calls Redis HEXISTS asynchronously. 
func (cc *Cluster) AsyncHexists(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHexists, args...)
}

// AsyncHget calls Redis HGET asynchronously. 
func (cc *Cluster) AsyncHget(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHget, args...)
}

// AsyncHgetall calls Redis HGETALL asynchronously. 
func (cc *Cluster) AsyncHgetall(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHgetall, args...)
}

// AsyncHincrby calls Redis HINCRBY asynchronously. 
func (cc *Cluster) AsyncHincrby(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHincrby, args...)
}

// AsyncHincrbyfloat calls Redis HINCRBYFLOAT asynchronously. 
func (cc *Cluster) AsyncHincrbyfloat(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHincrbyfloat, args...)
}

// AsyncHkeys calls Redis HKEYS asynchronously. 
func (cc *Cluster) AsyncHkeys(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHkeys, args...)
}

// AsyncHlen calls Redis HLEN asynchronously. 
func (cc *Cluster) AsyncHlen(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHlen, args...)
}

// AsyncHmget calls Redis HMGET asynchronously. 
func (cc *Cluster) AsyncHmget(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHmget, args...)
}

// AsyncHmset calls Redis HMSET asynchronously. 
func (cc *Cluster) AsyncHmset(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHmset, args...)
}

// AsyncHset calls Redis HSET asynchronously. 
func (cc *Cluster) AsyncHset(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHset, args...)
}

// AsyncHsetnx calls Redis HSETNX asynchronously. 
func (cc *Cluster) AsyncHsetnx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHsetnx, args...)
}

// AsyncHvals calls Redis HVALS asynchronously. 
func (cc *Cluster) AsyncHvals(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdHvals, args...)
}

// AsyncIncr calls Redis INCR asynchronously. 
func (cc *Cluster) AsyncIncr(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdIncr, args...)
}

// AsyncIncrby calls Redis INCRBY asynchronously. 
func (cc *Cluster) AsyncIncrby(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdIncrby, args...)
}

// AsyncIncrbyfloat calls Redis INCRBYFLOAT asynchronously. 
func (cc *Cluster) AsyncIncrbyfloat(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdIncrbyfloat, args...)
}

// AsyncInfo calls Redis INFO asynchronously. 
func (cc *Cluster) AsyncInfo(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdInfo, args...)
}

// AsyncKeys calls Redis KEYS asynchronously. 
func (cc *Cluster) AsyncKeys(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdKeys, args...)
}

// AsyncLastsave calls Redis LASTSAVE asynchronously. 
func (cc *Cluster) AsyncLastsave(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLastsave, args...)
}

// AsyncLindex calls Redis LINDEX asynchronously. 
func (cc *Cluster) AsyncLindex(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLindex, args...)
}

// AsyncLinsert calls Redis LINSERT asynchronously. 
func (cc *Cluster) AsyncLinsert(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLinsert, args...)
}

// AsyncLlen calls Redis LLEN asynchronously. 
func (cc *Cluster) AsyncLlen(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLlen, args...)
}

// AsyncLpop calls Redis LPOP asynchronously. 
func (cc *Cluster) AsyncLpop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLpop, args...)
}

// AsyncLpush calls Redis LPUSH asynchronously. 
func (cc *Cluster) AsyncLpush(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLpush, args...)
}

// AsyncLpushx calls Redis LPUSHX asynchronously. 
func (cc *Cluster) AsyncLpushx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLpushx, args...)
}

// AsyncLrange calls Redis LRANGE asynchronously. 
func (cc *Cluster) AsyncLrange(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLrange, args...)
}

// AsyncLrem calls Redis LREM asynchronously. 
func (cc *Cluster) AsyncLrem(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLrem, args...)
}

// AsyncLset calls Redis LSET asynchronously. 
func (cc *Cluster) AsyncLset(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLset, args...)
}

// AsyncLtrim calls Redis LTRIM asynchronously. 
func (cc *Cluster) AsyncLtrim(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdLtrim, args...)
}

// AsyncMget calls Redis MGET asynchronously. 
func (cc *Cluster) AsyncMget(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMget, args...)
}

// AsyncMigrate calls Redis MIGRATE asynchronously. 
func (cc *Cluster) AsyncMigrate(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMigrate, args...)
}

// AsyncMonitor calls Redis MONITOR asynchronously. 
func (cc *Cluster) AsyncMonitor(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMonitor, args...)
}

// AsyncMove calls Redis MOVE asynchronously. 
func (cc *Cluster) AsyncMove(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMove, args...)
}

// AsyncMset calls Redis MSET asynchronously. 
func (cc *Cluster) AsyncMset(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMset, args...)
}

// AsyncMsetnx calls Redis MSETNX asynchronously. 
func (cc *Cluster) AsyncMsetnx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMsetnx, args...)
}

// AsyncMulti calls Redis MULTI asynchronously. 
func (cc *Cluster) AsyncMulti(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdMulti, args...)
}

// AsyncObject calls Redis OBJECT asynchronously. 
func (cc *Cluster) AsyncObject(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdObject, args...)
}

// AsyncPersist calls Redis PERSIST asynchronously. 
func (cc *Cluster) AsyncPersist(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPersist, args...)
}

// AsyncPexpire calls Redis PEXPIRE asynchronously. 
func (cc *Cluster) AsyncPexpire(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPexpire, args...)
}

// AsyncPexpireat calls Redis PEXPIREAT asynchronously. 
func (cc *Cluster) AsyncPexpireat(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPexpireat, args...)
}

// AsyncPing calls Redis PING asynchronously. 
func (cc *Cluster) AsyncPing(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPing, args...)
}

// AsyncPsetex calls Redis PSETEX asynchronously. 
func (cc *Cluster) AsyncPsetex(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPsetex, args...)
}

// AsyncPsubscribe calls Redis PSUBSCRIBE asynchronously. 
func (cc *Cluster) AsyncPsubscribe(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPsubscribe, args...)
}

// AsyncPttl calls Redis PTTL asynchronously. 
func (cc *Cluster) AsyncPttl(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPttl, args...)
}

// AsyncPublish calls Redis PUBLISH asynchronously. 
func (cc *Cluster) AsyncPublish(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPublish, args...)
}

// AsyncPunsubscribe calls Redis PUNSUBSCRIBE asynchronously. 
func (cc *Cluster) AsyncPunsubscribe(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdPunsubscribe, args...)
}

// AsyncRandomkey calls Redis RANDOMKEY asynchronously. 
func (cc *Cluster) AsyncRandomkey(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRandomkey, args...)
}

// AsyncRename calls Redis RENAME asynchronously. 
func (cc *Cluster) AsyncRename(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRename, args...)
}

// AsyncRenamenx calls Redis RENAMENX asynchronously. 
func (cc *Cluster) AsyncRenamenx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRenamenx, args...)
}

// AsyncReplconf calls Redis REPLCONF asynchronously. 
func (cc *Cluster) AsyncReplconf(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdReplconf, args...)
}

// AsyncRestore calls Redis RESTORE asynchronously. 
func (cc *Cluster) AsyncRestore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRestore, args...)
}

// AsyncRpop calls Redis RPOP asynchronously. 
func (cc *Cluster) AsyncRpop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRpop, args...)
}

// AsyncRpoplpush calls Redis RPOPLPUSH asynchronously. 
func (cc *Cluster) AsyncRpoplpush(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRpoplpush, args...)
}

// AsyncRpush calls Redis RPUSH asynchronously. 
func (cc *Cluster) AsyncRpush(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRpush, args...)
}

// AsyncRpushx calls Redis RPUSHX asynchronously. 
func (cc *Cluster) AsyncRpushx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdRpushx, args...)
}

// AsyncSadd calls Redis SADD asynchronously. 
func (cc *Cluster) AsyncSadd(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSadd, args...)
}

// AsyncSave calls Redis SAVE asynchronously. 
func (cc *Cluster) AsyncSave(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSave, args...)
}

// AsyncScard calls Redis SCARD asynchronously. 
func (cc *Cluster) AsyncScard(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdScard, args...)
}

// AsyncScript calls Redis SCRIPT asynchronously. 
func (cc *Cluster) AsyncScript(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdScript, args...)
}

// AsyncSdiff calls Redis SDIFF asynchronously. 
func (cc *Cluster) AsyncSdiff(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSdiff, args...)
}

// AsyncSdiffstore calls Redis SDIFFSTORE asynchronously. 
func (cc *Cluster) AsyncSdiffstore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSdiffstore, args...)
}

// AsyncSelect calls Redis SELECT asynchronously. 
func (cc *Cluster) AsyncSelect(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSelect, args...)
}

// AsyncSet calls Redis SET asynchronously. 
func (cc *Cluster) AsyncSet(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSet, args...)
}

// AsyncSetbit calls Redis SETBIT asynchronously. 
func (cc *Cluster) AsyncSetbit(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSetbit, args...)
}

// AsyncSetex calls Redis SETEX asynchronously. 
func (cc *Cluster) AsyncSetex(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSetex, args...)
}

// AsyncSetnx calls Redis SETNX asynchronously. 
func (cc *Cluster) AsyncSetnx(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSetnx, args...)
}

// AsyncSetrange calls Redis SETRANGE asynchronously. 
func (cc *Cluster) AsyncSetrange(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSetrange, args...)
}

// AsyncShutdown calls Redis SHUTDOWN asynchronously. 
func (cc *Cluster) AsyncShutdown(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdShutdown, args...)
}

// AsyncSinter calls Redis SINTER asynchronously. 
func (cc *Cluster) AsyncSinter(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSinter, args...)
}

// AsyncSinterstore calls Redis SINTERSTORE asynchronously. 
func (cc *Cluster) AsyncSinterstore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSinterstore, args...)
}

// AsyncSismember calls Redis SISMEMBER asynchronously. 
func (cc *Cluster) AsyncSismember(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSismember, args...)
}

// AsyncSlaveof calls Redis SLAVEOF asynchronously. 
func (cc *Cluster) AsyncSlaveof(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSlaveof, args...)
}

// AsyncSmembers calls Redis SMEMBERS asynchronously. 
func (cc *Cluster) AsyncSmembers(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSmembers, args...)
}

// AsyncSmove calls Redis SMOVE asynchronously. 
func (cc *Cluster) AsyncSmove(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSmove, args...)
}

// AsyncSort calls Redis SORT asynchronously. 
func (cc *Cluster) AsyncSort(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSort, args...)
}

// AsyncSpop calls Redis SPOP asynchronously. 
func (cc *Cluster) AsyncSpop(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSpop, args...)
}

// AsyncSrandmember calls Redis SRANDMEMBER asynchronously. 
func (cc *Cluster) AsyncSrandmember(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSrandmember, args...)
}

// AsyncSrem calls Redis SREM asynchronously. 
func (cc *Cluster) AsyncSrem(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSrem, args...)
}

// AsyncStrlen calls Redis STRLEN asynchronously. 
func (cc *Cluster) AsyncStrlen(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdStrlen, args...)
}

// AsyncSubscribe calls Redis SUBSCRIBE asynchronously. 
func (cc *Cluster) AsyncSubscribe(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSubscribe, args...)
}

// AsyncSunion calls Redis SUNION asynchronously. 
func (cc *Cluster) AsyncSunion(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSunion, args...)
}

// AsyncSunionstore calls Redis SUNIONSTORE asynchronously. 
func (cc *Cluster) AsyncSunionstore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSunionstore, args...)
}

// AsyncSync calls Redis SYNC asynchronously. 
func (cc *Cluster) AsyncSync(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdSync, args...)
}

// AsyncTime calls Redis TIME asynchronously. 
func (cc *Cluster) AsyncTime(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdTime, args...)
}

// AsyncTtl calls Redis TTL asynchronously. 
func (cc *Cluster) AsyncTtl(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdTtl, args...)
}

// AsyncType calls Redis TYPE asynchronously. 
func (cc *Cluster) AsyncType(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdType, args...)
}

// AsyncUnsubscribe calls Redis UNSUBSCRIBE asynchronously. 
func (cc *Cluster) AsyncUnsubscribe(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdUnsubscribe, args...)
}

// AsyncUnwatch calls Redis UNWATCH asynchronously. 
func (cc *Cluster) AsyncUnwatch(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdUnwatch, args...)
}

// AsyncWatch calls Redis WATCH asynchronously. 
func (cc *Cluster) AsyncWatch(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdWatch, args...)
}

// AsyncZadd calls Redis ZADD asynchronously. 
func (cc *Cluster) AsyncZadd(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZadd, args...)
}

// AsyncZcard calls Redis ZCARD asynchronously. 
func (cc *Cluster) AsyncZcard(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZcard, args...)
}

// AsyncZcount calls Redis ZCOUNT asynchronously. 
func (cc *Cluster) AsyncZcount(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZcount, args...)
}

// AsyncZincrby calls Redis ZINCRBY asynchronously. 
func (cc *Cluster) AsyncZincrby(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZincrby, args...)
}

// AsyncZinterstore calls Redis ZINTERSTORE asynchronously. 
func (cc *Cluster) AsyncZinterstore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZinterstore, args...)
}

// AsyncZrange calls Redis ZRANGE asynchronously. 
func (cc *Cluster) AsyncZrange(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrange, args...)
}

// AsyncZrangebyscore calls Redis ZRANGEBYSCORE asynchronously. 
func (cc *Cluster) AsyncZrangebyscore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrangebyscore, args...)
}

// AsyncZrank calls Redis ZRANK asynchronously. 
func (cc *Cluster) AsyncZrank(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrank, args...)
}

// AsyncZrem calls Redis ZREM asynchronously. 
func (cc *Cluster) AsyncZrem(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrem, args...)
}

// AsyncZremrangebyrank calls Redis ZREMRANGEBYRANK asynchronously. 
func (cc *Cluster) AsyncZremrangebyrank(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZremrangebyrank, args...)
}

// AsyncZremrangebyscore calls Redis ZREMRANGEBYSCORE asynchronously. 
func (cc *Cluster) AsyncZremrangebyscore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZremrangebyscore, args...)
}

// AsyncZrevrange calls Redis ZREVRANGE asynchronously. 
func (cc *Cluster) AsyncZrevrange(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrevrange, args...)
}

// AsyncZrevrangebyscore calls Redis ZREVRANGEBYSCORE asynchronously. 
func (cc *Cluster) AsyncZrevrangebyscore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrevrangebyscore, args...)
}

// AsyncZrevrank calls Redis ZREVRANK asynchronously. 
func (cc *Cluster) AsyncZrevrank(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZrevrank, args...)
}

// AsyncZscore calls Redis ZSCORE asynchronously. 
func (cc *Cluster) AsyncZscore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZscore, args...)
}

// AsyncZunionstore calls Redis ZUNIONSTORE asynchronously. 
func (cc *Cluster) AsyncZunionstore(args ...interface{}) redis.Future {
	return cc.AsyncCall(cmdZunionstore, args...)
}