nwnx_redis_short.nss

Go to the documentation of this file.

#include "nwnx_redis_lib"
 
 
// Skipping sub-command: BITFIELD/{"command"=>"OVERFLOW", "type"=>"enum", "enum"=>["WRAP", "SAT", "FAIL"], "optional"=>true} - not supported yet.
// Skipping sub-command: CLIENT_KILL/{"command"=>"TYPE", "type"=>"enum", "enum"=>["normal", "master", "slave", "pubsub"], "optional"=>true} - not supported yet.
// Skipping sub-command: CLIENT_LIST/{"command"=>"TYPE", "type"=>"enum", "enum"=>["normal", "master", "replica", "pubsub"], "optional"=>true} - not supported yet.
// Skipping sub-command: SET/{"command"=>"expiration", "type"=>"enum", "enum"=>["EX seconds", "PX milliseconds"], "optional"=>true} - not supported yet.
// Skipping XCLAIM, cannot parse argument: {"name"=>"force", "enum"=>["FORCE"], "optional"=>true} - not supported yet.
// Skipping XCLAIM, cannot parse argument: {"name"=>"justid", "enum"=>["JUSTID"], "optional"=>true} - not supported yet.
int APPEND(
    string key,
    string value
);
 
int AUTH(
    string password
);
 
int BGREWRITEAOF();
 
int BGSAVE();
 
int BITCOUNT(
    string key,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
);
 
int BITFIELD(
    string key,
    // Redis type: type
    string get_type = "",
    // Redis type: integer
    int get_offset = 0,
    // Redis type: type
    string set_type = "",
    // Redis type: integer
    int set_offset = 0,
    // Redis type: integer
    int set_value = 0,
    // Redis type: type
    string incrby_type = "",
    // Redis type: integer
    int incrby_offset = 0,
    // Redis type: integer
    int incrby_increment = 0
);
 
int BITOP(
    string operation,
    // Redis type: key
    string destkey,
    string key
);
 
int BITPOS(
    string key,
    // Redis type: integer
    int bit,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
);
 
int BLPOP(
    string key,
    // Redis type: integer
    int timeout
);
 
int BRPOP(
    string key,
    // Redis type: integer
    int timeout
);
 
int BRPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    // Redis type: integer
    int timeout
);
 
int BZPOPMIN(
    string key,
    // Redis type: integer
    int timeout
);
 
int BZPOPMAX(
    string key,
    // Redis type: integer
    int timeout
);
 
int CLIENT_ID();
 
int CLIENT_KILL(
    string ip_port = "",
    // Redis type: integer
    int id_client_id = 0,
    string addr_ip_port = "",
    string skipme_yes_no = ""
);
 
int CLIENT_LIST();
 
int CLIENT_GETNAME();
 
int CLIENT_PAUSE(
    // Redis type: integer
    int timeout
);
 
int CLIENT_REPLY(
    // Redis type: enum
    string reply_mode
);
 
int CLIENT_SETNAME(
    string connection_name
);
 
int CLIENT_UNBLOCK(
    string client_id,
    // Redis type: enum
    string unblock_type = ""
);
 
int CLUSTER_ADDSLOTS(
    // Redis type: integer
    int slot
);
 
int CLUSTER_COUNT_FAILURE_REPORTS(
    string node_id
);
 
int CLUSTER_COUNTKEYSINSLOT(
    // Redis type: integer
    int slot
);
 
int CLUSTER_DELSLOTS(
    // Redis type: integer
    int slot
);
 
int CLUSTER_FAILOVER(
    // Redis type: enum
    string options = ""
);
 
int CLUSTER_FORGET(
    string node_id
);
 
int CLUSTER_GETKEYSINSLOT(
    // Redis type: integer
    int slot,
    // Redis type: integer
    int count
);
 
int CLUSTER_INFO();
 
int CLUSTER_KEYSLOT(
    string key
);
 
int CLUSTER_MEET(
    string ip,
    // Redis type: integer
    int port
);
 
int CLUSTER_NODES();
 
int CLUSTER_REPLICATE(
    string node_id
);
 
int CLUSTER_RESET(
    // Redis type: enum
    string reset_type = ""
);
 
int CLUSTER_SAVECONFIG();
 
int CLUSTER_SET_CONFIG_EPOCH(
    // Redis type: integer
    int config_epoch
);
 
int CLUSTER_SETSLOT(
    // Redis type: integer
    int slot,
    // Redis type: enum
    string subcommand,
    string node_id = ""
);
 
int CLUSTER_SLAVES(
    string node_id
);
 
int CLUSTER_REPLICAS(
    string node_id
);
 
int CLUSTER_SLOTS();
 
int COMMAND();
 
int COMMAND_COUNT();
 
int COMMAND_GETKEYS();
 
int COMMAND_INFO(
    string command_name
);
 
int CONFIG_GET(
    string parameter
);
 
int CONFIG_REWRITE();
 
int CONFIG_SET(
    string parameter,
    string value
);
 
int CONFIG_RESETSTAT();
 
int DBSIZE();
 
int DEBUG_OBJECT(
    string key
);
 
int DEBUG_SEGFAULT();
 
int DECR(
    string key
);
 
int DECRBY(
    string key,
    // Redis type: integer
    int decrement
);
 
int DEL(
    string key
);
 
int DISCARD();
 
int DUMP(
    string key
);
 
int ECHO(
    string message
);
 
int EVAL(
    string script,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
);
 
int EVALSHA(
    string sha1,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
);
 
int EXEC();
 
int EXISTS(
    string key
);
 
int EXPIRE(
    string key,
    // Redis type: integer
    int seconds
);
 
int EXPIREAT(
    string key,
    // Redis type: posix time
    string timestamp
);
 
int FLUSHALL(
    // Redis type: enum
    string async = ""
);
 
int FLUSHDB(
    // Redis type: enum
    string async = ""
);
 
int GEOADD(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    string member
);
 
int GEOHASH(
    string key,
    string member
);
 
int GEOPOS(
    string key,
    string member
);
 
int GEODIST(
    string key,
    string member1,
    string member2,
    string unit = ""
);
 
int GEORADIUS(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    // Redis type: double
    float radius,
    // Redis type: enum
    string unit,
    // Redis type: enum
    string withcoord = "",
    // Redis type: enum
    string withdist = "",
    // Redis type: enum
    string withhash = "",
    // Redis type: integer
    int count_count = 0,
    // Redis type: enum
    string order = "",
    // Redis type: key
    string store_key = "",
    // Redis type: key
    string storedist_key = ""
);
 
int GEORADIUSBYMEMBER(
    string key,
    string member,
    // Redis type: double
    float radius,
    // Redis type: enum
    string unit,
    // Redis type: enum
    string withcoord = "",
    // Redis type: enum
    string withdist = "",
    // Redis type: enum
    string withhash = "",
    // Redis type: integer
    int count_count = 0,
    // Redis type: enum
    string order = "",
    // Redis type: key
    string store_key = "",
    // Redis type: key
    string storedist_key = ""
);
 
int GET(
    string key
);
 
int GETBIT(
    string key,
    // Redis type: integer
    int offset
);
 
int GETRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int end
);
 
int GETSET(
    string key,
    string value
);
 
int HDEL(
    string key,
    string field
);
 
int HEXISTS(
    string key,
    string field
);
 
int HGET(
    string key,
    string field
);
 
int HGETALL(
    string key
);
 
int HINCRBY(
    string key,
    string field,
    // Redis type: integer
    int increment
);
 
int HINCRBYFLOAT(
    string key,
    string field,
    // Redis type: double
    float increment
);
 
int HKEYS(
    string key
);
 
int HLEN(
    string key
);
 
int HMGET(
    string key,
    string field
);
 
int HMSET(
    string key,
    string field,
    string value
);
 
int HSET(
    string key,
    string field,
    string value
);
 
int HSETNX(
    string key,
    string field,
    string value
);
 
int HSTRLEN(
    string key,
    string field
);
 
int HVALS(
    string key
);
 
int INCR(
    string key
);
 
int INCRBY(
    string key,
    // Redis type: integer
    int increment
);
 
int INCRBYFLOAT(
    string key,
    // Redis type: double
    float increment
);
 
int INFO(
    string section = ""
);
 
int KEYS(
    string pattern
);
 
int LASTSAVE();
 
int LINDEX(
    string key,
    // Redis type: integer
    int index
);
 
int LINSERT(
    string key,
    // Redis type: enum
    string where,
    string pivot,
    string value
);
 
int LLEN(
    string key
);
 
int LPOP(
    string key
);
 
int LPUSH(
    string key,
    string value
);
 
int LPUSHX(
    string key,
    string value
);
 
int LRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int LREM(
    string key,
    // Redis type: integer
    int count,
    string value
);
 
int LSET(
    string key,
    // Redis type: integer
    int index,
    string value
);
 
int LTRIM(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int MEMORY_DOCTOR();
 
int MEMORY_HELP();
 
int MEMORY_MALLOC_STATS();
 
int MEMORY_PURGE();
 
int MEMORY_STATS();
 
int MEMORY_USAGE(
    string key,
    // Redis type: integer
    int samples_count = 0
);
 
int MGET(
    string key
);
 
int MIGRATE(
    string host,
    string port,
    // Redis type: enum
    string key,
    // Redis type: integer
    int destination_db,
    // Redis type: integer
    int timeout,
    // Redis type: enum
    string copy = "",
    // Redis type: enum
    string replace = "",
    string auth_password = "",
    // Redis type: key
    string keys_key = ""
);
 
int MONITOR();
 
int MOVE(
    string key,
    // Redis type: integer
    int db
);
 
int MSET(
    string key,
    string value
);
 
int MSETNX(
    string key,
    string value
);
 
int MULTI();
 
int OBJECT(
    string subcommand,
    string arguments = ""
);
 
int PERSIST(
    string key
);
 
int PEXPIRE(
    string key,
    // Redis type: integer
    int milliseconds
);
 
int PEXPIREAT(
    string key,
    // Redis type: posix time
    string milliseconds_timestamp
);
 
int PFADD(
    string key,
    string element
);
 
int PFCOUNT(
    string key
);
 
int PFMERGE(
    // Redis type: key
    string destkey,
    // Redis type: key
    string sourcekey
);
 
int PING(
    string message = ""
);
 
int PSETEX(
    string key,
    // Redis type: integer
    int milliseconds,
    string value
);
 
int PUBSUB(
    string subcommand,
    string argument = ""
);
 
int PTTL(
    string key
);
 
int PUBLISH(
    string channel,
    string message
);
 
int QUIT();
 
int RANDOMKEY();
 
int READONLY();
 
int READWRITE();
 
int RENAME(
    string key,
    // Redis type: key
    string newkey
);
 
int RENAMENX(
    string key,
    // Redis type: key
    string newkey
);
 
int RESTORE(
    string key,
    // Redis type: integer
    int ttl,
    string serialized_value,
    // Redis type: enum
    string replace = "",
    // Redis type: enum
    string absttl = "",
    // Redis type: integer
    int idletime_seconds = 0,
    // Redis type: integer
    int freq_frequency = 0
);
 
int ROLE();
 
int RPOP(
    string key
);
 
int RPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination
);
 
int RPUSH(
    string key,
    string value
);
 
int RPUSHX(
    string key,
    string value
);
 
int SADD(
    string key,
    string member
);
 
int SAVE();
 
int SCARD(
    string key
);
 
int SCRIPT_DEBUG(
    // Redis type: enum
    string mode
);
 
int SCRIPT_EXISTS(
    string sha1
);
 
int SCRIPT_FLUSH();
 
int SCRIPT_KILL();
 
int SCRIPT_LOAD(
    string script
);
 
int SDIFF(
    string key
);
 
int SDIFFSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int SELECT(
    // Redis type: integer
    int index
);
 
int SET(
    string key,
    string value,
    // Redis type: enum
    string condition = ""
);
 
int SETBIT(
    string key,
    // Redis type: integer
    int offset,
    string value
);
 
int SETEX(
    string key,
    // Redis type: integer
    int seconds,
    string value
);
 
int SETNX(
    string key,
    string value
);
 
int SETRANGE(
    string key,
    // Redis type: integer
    int offset,
    string value
);
 
int SHUTDOWN(
    // Redis type: enum
    string save_mode = ""
);
 
int SINTER(
    string key
);
 
int SINTERSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int SISMEMBER(
    string key,
    string member
);
 
int SLAVEOF(
    string host,
    string port
);
 
int REPLICAOF(
    string host,
    string port
);
 
int SLOWLOG(
    string subcommand,
    string argument = ""
);
 
int SMEMBERS(
    string key
);
 
int SMOVE(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    string member
);
 
int SORT(
    string key,
    // Redis type: pattern
    string by_pattern = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0,
    string get_pattern = "",
    // Redis type: enum
    string order = "",
    // Redis type: enum
    string sorting = "",
    // Redis type: key
    string store_destination = ""
);
 
int SPOP(
    string key,
    // Redis type: integer
    int count = 0
);
 
int SRANDMEMBER(
    string key,
    // Redis type: integer
    int count = 0
);
 
int SREM(
    string key,
    string member
);
 
int STRLEN(
    string key
);
 
int SUNION(
    string key
);
 
int SUNIONSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int SWAPDB(
    // Redis type: integer
    int index,
    // Redis type: integer
    int index_1
);
 
int SYNC();
 
int TIME();
 
int TOUCH(
    string key
);
 
int TTL(
    string key
);
 
int TYPE(
    string key
);
 
int UNLINK(
    string key
);
 
int UNWATCH();
 
int WAIT(
    // Redis type: integer
    int numreplicas,
    // Redis type: integer
    int timeout
);
 
int WATCH(
    string key
);
 
int ZADD(
    string key,
    // Redis type: enum
    string condition = "",
    // Redis type: enum
    string change = "",
    // Redis type: enum
    string increment = "",
    // Redis type: double
    float score = 0.0,
    string member = ""
);
 
int ZCARD(
    string key
);
 
int ZCOUNT(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
);
 
int ZINCRBY(
    string key,
    // Redis type: integer
    int increment,
    string member
);
 
int ZINTERSTORE(
    // Redis type: key
    string destination,
    // Redis type: integer
    int numkeys,
    string key,
    // Redis type: integer
    int weights_weight = 0,
    // Redis type: enum
    string aggregate_aggregate = ""
);
 
int ZLEXCOUNT(
    string key,
    string min,
    string max
);
 
int ZPOPMAX(
    string key,
    // Redis type: integer
    int count = 0
);
 
int ZPOPMIN(
    string key,
    // Redis type: integer
    int count = 0
);
 
int ZRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
);
 
int ZRANGEBYLEX(
    string key,
    string min,
    string max,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int ZREVRANGEBYLEX(
    string key,
    string max,
    string min,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int ZRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max,
    // Redis type: enum
    string withscores = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int ZRANK(
    string key,
    string member
);
 
int ZREM(
    string key,
    string member
);
 
int ZREMRANGEBYLEX(
    string key,
    string min,
    string max
);
 
int ZREMRANGEBYRANK(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int ZREMRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
);
 
int ZREVRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
);
 
int ZREVRANGEBYSCORE(
    string key,
    // Redis type: double
    float max,
    // Redis type: double
    float min,
    // Redis type: enum
    string withscores = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int ZREVRANK(
    string key,
    string member
);
 
int ZSCORE(
    string key,
    string member
);
 
int ZUNIONSTORE(
    // Redis type: key
    string destination,
    // Redis type: integer
    int numkeys,
    string key,
    // Redis type: integer
    int weights_weight = 0,
    // Redis type: enum
    string aggregate_aggregate = ""
);
 
int SCAN(
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0,
    string type_type = ""
);
 
int SSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int HSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int ZSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int XINFO(
    // Redis type: key
    string consumers_key = "",
    string consumers_groupname = "",
    // Redis type: key
    string groups_key = "",
    // Redis type: key
    string stream_key = "",
    // Redis type: enum
    string help = ""
);
 
int XADD(
    string key,
    string ID,
    // Redis type: value
    string field,
    string str
);
 
int XTRIM(
    string key,
    // Redis type: enum
    string strategy,
    // Redis type: enum
    string approx = "",
    // Redis type: integer
    int count = 0
);
 
int XDEL(
    string key,
    string ID
);
 
int XRANGE(
    string key,
    string start,
    string end,
    // Redis type: integer
    int count_count = 0
);
 
int XREVRANGE(
    string key,
    string end,
    string start,
    // Redis type: integer
    int count_count = 0
);
 
int XLEN(
    string key
);
 
int XREAD(
    // Redis type: integer
    int count_count = 0,
    // Redis type: integer
    int block_milliseconds = 0,
    // Redis type: enum
    string streams = "",
    string key = "",
    string ID = ""
);
 
int XGROUP(
    // Redis type: key
    string create_key = "",
    string create_groupname = "",
    string create_id_or__ = "",
    // Redis type: key
    string setid_key = "",
    string setid_groupname = "",
    string setid_id_or__ = "",
    // Redis type: key
    string destroy_key = "",
    string destroy_groupname = "",
    // Redis type: key
    string delconsumer_key = "",
    string delconsumer_groupname = "",
    string delconsumer_consumername = ""
);
 
int XREADGROUP(
    string group_group,
    string group_consumer,
    // Redis type: integer
    int count_count = 0,
    // Redis type: integer
    int block_milliseconds = 0,
    // Redis type: enum
    string noack = "",
    // Redis type: enum
    string streams = "",
    string key = "",
    string ID = ""
);
 
int XACK(
    string key,
    string group,
    string ID
);
 
int XCLAIM(
    string key,
    string group,
    string consumer,
    string min_idle_time,
    string ID,
    // Redis type: integer
    int idle_ms = 0,
    // Redis type: integer
    int time_ms_unix_time = 0,
    // Redis type: integer
    int retrycount_count = 0
);
 
int XPENDING(
    string key,
    string group,
    string start = "",
    string end = "",
    // Redis type: integer
    int count = 0,
    string consumer = ""
);
 
 
 
// Implementation below
int APPEND(
    string key,
    string value
) {
  NWNXPushString("APPEND");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int AUTH(
    string password
) {
  NWNXPushString("AUTH");
  NWNXPushString(password);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BGREWRITEAOF() {
  NWNXPushString("BGREWRITEAOF");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BGSAVE() {
  NWNXPushString("BGSAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BITCOUNT(
    string key,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
) {
  NWNXPushString("BITCOUNT");
  NWNXPushString(key);
  if (start != 0) NWNXPushString(IntToString(start));
  if (end != 0) NWNXPushString(IntToString(end));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BITFIELD(
    string key,
    // Redis type: type
    string get_type = "",
    // Redis type: integer
    int get_offset = 0,
    // Redis type: type
    string set_type = "",
    // Redis type: integer
    int set_offset = 0,
    // Redis type: integer
    int set_value = 0,
    // Redis type: type
    string incrby_type = "",
    // Redis type: integer
    int incrby_offset = 0,
    // Redis type: integer
    int incrby_increment = 0
) {
  NWNXPushString("BITFIELD");
  NWNXPushString(key);
  if (get_type != "") NWNXPushString(get_type);
  if (get_offset != 0) NWNXPushString(IntToString(get_offset));
  if (set_type != "") NWNXPushString(set_type);
  if (set_offset != 0) NWNXPushString(IntToString(set_offset));
  if (set_value != 0) NWNXPushString(IntToString(set_value));
  if (incrby_type != "") NWNXPushString(incrby_type);
  if (incrby_offset != 0) NWNXPushString(IntToString(incrby_offset));
  if (incrby_increment != 0) NWNXPushString(IntToString(incrby_increment));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BITOP(
    string operation,
    // Redis type: key
    string destkey,
    string key
) {
  NWNXPushString("BITOP");
  NWNXPushString(operation);
  NWNXPushString(destkey);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BITPOS(
    string key,
    // Redis type: integer
    int bit,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
) {
  NWNXPushString("BITPOS");
  NWNXPushString(key);
  NWNXPushString(IntToString(bit));
  if (start != 0) NWNXPushString(IntToString(start));
  if (end != 0) NWNXPushString(IntToString(end));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BLPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BLPOP");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BRPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BRPOP");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BRPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BRPOPLPUSH");
  NWNXPushString(source);
  NWNXPushString(destination);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BZPOPMIN(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BZPOPMIN");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int BZPOPMAX(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BZPOPMAX");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_ID() {
  NWNXPushString("CLIENT_ID");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_KILL(
    string ip_port = "",
    // Redis type: integer
    int id_client_id = 0,
    string addr_ip_port = "",
    string skipme_yes_no = ""
) {
  NWNXPushString("CLIENT_KILL");
  if (ip_port != "") NWNXPushString(ip_port);
  if (id_client_id != 0) NWNXPushString(IntToString(id_client_id));
  if (addr_ip_port != "") NWNXPushString(addr_ip_port);
  if (skipme_yes_no != "") NWNXPushString(skipme_yes_no);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_LIST() {
  NWNXPushString("CLIENT_LIST");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_GETNAME() {
  NWNXPushString("CLIENT_GETNAME");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_PAUSE(
    // Redis type: integer
    int timeout
) {
  NWNXPushString("CLIENT_PAUSE");
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_REPLY(
    // Redis type: enum
    string reply_mode
) {
  NWNXPushString("CLIENT_REPLY");
  NWNXPushString(reply_mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_SETNAME(
    string connection_name
) {
  NWNXPushString("CLIENT_SETNAME");
  NWNXPushString(connection_name);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLIENT_UNBLOCK(
    string client_id,
    // Redis type: enum
    string unblock_type = ""
) {
  NWNXPushString("CLIENT_UNBLOCK");
  NWNXPushString(client_id);
  if (unblock_type != "") NWNXPushString(unblock_type);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_ADDSLOTS(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_ADDSLOTS");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_COUNT_FAILURE_REPORTS(
    string node_id
) {
  NWNXPushString("CLUSTER_COUNT_FAILURE_REPORTS");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_COUNTKEYSINSLOT(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_COUNTKEYSINSLOT");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_DELSLOTS(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_DELSLOTS");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_FAILOVER(
    // Redis type: enum
    string options = ""
) {
  NWNXPushString("CLUSTER_FAILOVER");
  if (options != "") NWNXPushString(options);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_FORGET(
    string node_id
) {
  NWNXPushString("CLUSTER_FORGET");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_GETKEYSINSLOT(
    // Redis type: integer
    int slot,
    // Redis type: integer
    int count
) {
  NWNXPushString("CLUSTER_GETKEYSINSLOT");
  NWNXPushString(IntToString(slot));
  NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_INFO() {
  NWNXPushString("CLUSTER_INFO");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_KEYSLOT(
    string key
) {
  NWNXPushString("CLUSTER_KEYSLOT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_MEET(
    string ip,
    // Redis type: integer
    int port
) {
  NWNXPushString("CLUSTER_MEET");
  NWNXPushString(ip);
  NWNXPushString(IntToString(port));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_NODES() {
  NWNXPushString("CLUSTER_NODES");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_REPLICATE(
    string node_id
) {
  NWNXPushString("CLUSTER_REPLICATE");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_RESET(
    // Redis type: enum
    string reset_type = ""
) {
  NWNXPushString("CLUSTER_RESET");
  if (reset_type != "") NWNXPushString(reset_type);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_SAVECONFIG() {
  NWNXPushString("CLUSTER_SAVECONFIG");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_SET_CONFIG_EPOCH(
    // Redis type: integer
    int config_epoch
) {
  NWNXPushString("CLUSTER_SET_CONFIG_EPOCH");
  NWNXPushString(IntToString(config_epoch));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_SETSLOT(
    // Redis type: integer
    int slot,
    // Redis type: enum
    string subcommand,
    string node_id = ""
) {
  NWNXPushString("CLUSTER_SETSLOT");
  NWNXPushString(IntToString(slot));
  NWNXPushString(subcommand);
  if (node_id != "") NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_SLAVES(
    string node_id
) {
  NWNXPushString("CLUSTER_SLAVES");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_REPLICAS(
    string node_id
) {
  NWNXPushString("CLUSTER_REPLICAS");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CLUSTER_SLOTS() {
  NWNXPushString("CLUSTER_SLOTS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int COMMAND() {
  NWNXPushString("COMMAND");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int COMMAND_COUNT() {
  NWNXPushString("COMMAND_COUNT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int COMMAND_GETKEYS() {
  NWNXPushString("COMMAND_GETKEYS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int COMMAND_INFO(
    string command_name
) {
  NWNXPushString("COMMAND_INFO");
  NWNXPushString(command_name);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CONFIG_GET(
    string parameter
) {
  NWNXPushString("CONFIG_GET");
  NWNXPushString(parameter);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CONFIG_REWRITE() {
  NWNXPushString("CONFIG_REWRITE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CONFIG_SET(
    string parameter,
    string value
) {
  NWNXPushString("CONFIG_SET");
  NWNXPushString(parameter);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int CONFIG_RESETSTAT() {
  NWNXPushString("CONFIG_RESETSTAT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DBSIZE() {
  NWNXPushString("DBSIZE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DEBUG_OBJECT(
    string key
) {
  NWNXPushString("DEBUG_OBJECT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DEBUG_SEGFAULT() {
  NWNXPushString("DEBUG_SEGFAULT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DECR(
    string key
) {
  NWNXPushString("DECR");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DECRBY(
    string key,
    // Redis type: integer
    int decrement
) {
  NWNXPushString("DECRBY");
  NWNXPushString(key);
  NWNXPushString(IntToString(decrement));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DEL(
    string key
) {
  NWNXPushString("DEL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DISCARD() {
  NWNXPushString("DISCARD");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int DUMP(
    string key
) {
  NWNXPushString("DUMP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ECHO(
    string message
) {
  NWNXPushString("ECHO");
  NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EVAL(
    string script,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
) {
  NWNXPushString("EVAL");
  NWNXPushString(script);
  NWNXPushString(IntToString(numkeys));
  NWNXPushString(key);
  NWNXPushString(arg);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EVALSHA(
    string sha1,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
) {
  NWNXPushString("EVALSHA");
  NWNXPushString(sha1);
  NWNXPushString(IntToString(numkeys));
  NWNXPushString(key);
  NWNXPushString(arg);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EXEC() {
  NWNXPushString("EXEC");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EXISTS(
    string key
) {
  NWNXPushString("EXISTS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EXPIRE(
    string key,
    // Redis type: integer
    int seconds
) {
  NWNXPushString("EXPIRE");
  NWNXPushString(key);
  NWNXPushString(IntToString(seconds));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int EXPIREAT(
    string key,
    // Redis type: posix time
    string timestamp
) {
  NWNXPushString("EXPIREAT");
  NWNXPushString(key);
  NWNXPushString(timestamp);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int FLUSHALL(
    // Redis type: enum
    string async = ""
) {
  NWNXPushString("FLUSHALL");
  if (async != "") NWNXPushString(async);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int FLUSHDB(
    // Redis type: enum
    string async = ""
) {
  NWNXPushString("FLUSHDB");
  if (async != "") NWNXPushString(async);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEOADD(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    string member
) {
  NWNXPushString("GEOADD");
  NWNXPushString(key);
  NWNXPushString(FloatToString(longitude, 0));
  NWNXPushString(FloatToString(latitude, 0));
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEOHASH(
    string key,
    string member
) {
  NWNXPushString("GEOHASH");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEOPOS(
    string key,
    string member
) {
  NWNXPushString("GEOPOS");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEODIST(
    string key,
    string member1,
    string member2,
    string unit = ""
) {
  NWNXPushString("GEODIST");
  NWNXPushString(key);
  NWNXPushString(member1);
  NWNXPushString(member2);
  if (unit != "") NWNXPushString(unit);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEORADIUS(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    // Redis type: double
    float radius,
    // Redis type: enum
    string unit,
    // Redis type: enum
    string withcoord = "",
    // Redis type: enum
    string withdist = "",
    // Redis type: enum
    string withhash = "",
    // Redis type: integer
    int count_count = 0,
    // Redis type: enum
    string order = "",
    // Redis type: key
    string store_key = "",
    // Redis type: key
    string storedist_key = ""
) {
  NWNXPushString("GEORADIUS");
  NWNXPushString(key);
  NWNXPushString(FloatToString(longitude, 0));
  NWNXPushString(FloatToString(latitude, 0));
  NWNXPushString(FloatToString(radius, 0));
  NWNXPushString(unit);
  if (withcoord != "") NWNXPushString(withcoord);
  if (withdist != "") NWNXPushString(withdist);
  if (withhash != "") NWNXPushString(withhash);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  if (order != "") NWNXPushString(order);
  if (store_key != "") NWNXPushString(store_key);
  if (storedist_key != "") NWNXPushString(storedist_key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GEORADIUSBYMEMBER(
    string key,
    string member,
    // Redis type: double
    float radius,
    // Redis type: enum
    string unit,
    // Redis type: enum
    string withcoord = "",
    // Redis type: enum
    string withdist = "",
    // Redis type: enum
    string withhash = "",
    // Redis type: integer
    int count_count = 0,
    // Redis type: enum
    string order = "",
    // Redis type: key
    string store_key = "",
    // Redis type: key
    string storedist_key = ""
) {
  NWNXPushString("GEORADIUSBYMEMBER");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXPushString(FloatToString(radius, 0));
  NWNXPushString(unit);
  if (withcoord != "") NWNXPushString(withcoord);
  if (withdist != "") NWNXPushString(withdist);
  if (withhash != "") NWNXPushString(withhash);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  if (order != "") NWNXPushString(order);
  if (store_key != "") NWNXPushString(store_key);
  if (storedist_key != "") NWNXPushString(storedist_key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GET(
    string key
) {
  NWNXPushString("GET");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GETBIT(
    string key,
    // Redis type: integer
    int offset
) {
  NWNXPushString("GETBIT");
  NWNXPushString(key);
  NWNXPushString(IntToString(offset));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GETRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int end
) {
  NWNXPushString("GETRANGE");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(end));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int GETSET(
    string key,
    string value
) {
  NWNXPushString("GETSET");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HDEL(
    string key,
    string field
) {
  NWNXPushString("HDEL");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HEXISTS(
    string key,
    string field
) {
  NWNXPushString("HEXISTS");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HGET(
    string key,
    string field
) {
  NWNXPushString("HGET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HGETALL(
    string key
) {
  NWNXPushString("HGETALL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HINCRBY(
    string key,
    string field,
    // Redis type: integer
    int increment
) {
  NWNXPushString("HINCRBY");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(IntToString(increment));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HINCRBYFLOAT(
    string key,
    string field,
    // Redis type: double
    float increment
) {
  NWNXPushString("HINCRBYFLOAT");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(FloatToString(increment, 0));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HKEYS(
    string key
) {
  NWNXPushString("HKEYS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HLEN(
    string key
) {
  NWNXPushString("HLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HMGET(
    string key,
    string field
) {
  NWNXPushString("HMGET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HMSET(
    string key,
    string field,
    string value
) {
  NWNXPushString("HMSET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HSET(
    string key,
    string field,
    string value
) {
  NWNXPushString("HSET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HSETNX(
    string key,
    string field,
    string value
) {
  NWNXPushString("HSETNX");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HSTRLEN(
    string key,
    string field
) {
  NWNXPushString("HSTRLEN");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HVALS(
    string key
) {
  NWNXPushString("HVALS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int INCR(
    string key
) {
  NWNXPushString("INCR");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int INCRBY(
    string key,
    // Redis type: integer
    int increment
) {
  NWNXPushString("INCRBY");
  NWNXPushString(key);
  NWNXPushString(IntToString(increment));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int INCRBYFLOAT(
    string key,
    // Redis type: double
    float increment
) {
  NWNXPushString("INCRBYFLOAT");
  NWNXPushString(key);
  NWNXPushString(FloatToString(increment, 0));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int INFO(
    string section = ""
) {
  NWNXPushString("INFO");
  if (section != "") NWNXPushString(section);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int KEYS(
    string pattern
) {
  NWNXPushString("KEYS");
  NWNXPushString(pattern);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LASTSAVE() {
  NWNXPushString("LASTSAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LINDEX(
    string key,
    // Redis type: integer
    int index
) {
  NWNXPushString("LINDEX");
  NWNXPushString(key);
  NWNXPushString(IntToString(index));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LINSERT(
    string key,
    // Redis type: enum
    string where,
    string pivot,
    string value
) {
  NWNXPushString("LINSERT");
  NWNXPushString(key);
  NWNXPushString(where);
  NWNXPushString(pivot);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LLEN(
    string key
) {
  NWNXPushString("LLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LPOP(
    string key
) {
  NWNXPushString("LPOP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LPUSH(
    string key,
    string value
) {
  NWNXPushString("LPUSH");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LPUSHX(
    string key,
    string value
) {
  NWNXPushString("LPUSHX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNXPushString("LRANGE");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(stop));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LREM(
    string key,
    // Redis type: integer
    int count,
    string value
) {
  NWNXPushString("LREM");
  NWNXPushString(key);
  NWNXPushString(IntToString(count));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LSET(
    string key,
    // Redis type: integer
    int index,
    string value
) {
  NWNXPushString("LSET");
  NWNXPushString(key);
  NWNXPushString(IntToString(index));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int LTRIM(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNXPushString("LTRIM");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(stop));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_DOCTOR() {
  NWNXPushString("MEMORY_DOCTOR");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_HELP() {
  NWNXPushString("MEMORY_HELP");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_MALLOC_STATS() {
  NWNXPushString("MEMORY_MALLOC_STATS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_PURGE() {
  NWNXPushString("MEMORY_PURGE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_STATS() {
  NWNXPushString("MEMORY_STATS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MEMORY_USAGE(
    string key,
    // Redis type: integer
    int samples_count = 0
) {
  NWNXPushString("MEMORY_USAGE");
  NWNXPushString(key);
  if (samples_count != 0) NWNXPushString(IntToString(samples_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MGET(
    string key
) {
  NWNXPushString("MGET");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MIGRATE(
    string host,
    string port,
    // Redis type: enum
    string key,
    // Redis type: integer
    int destination_db,
    // Redis type: integer
    int timeout,
    // Redis type: enum
    string copy = "",
    // Redis type: enum
    string replace = "",
    string auth_password = "",
    // Redis type: key
    string keys_key = ""
) {
  NWNXPushString("MIGRATE");
  NWNXPushString(host);
  NWNXPushString(port);
  NWNXPushString(key);
  NWNXPushString(IntToString(destination_db));
  NWNXPushString(IntToString(timeout));
  if (copy != "") NWNXPushString(copy);
  if (replace != "") NWNXPushString(replace);
  if (auth_password != "") NWNXPushString(auth_password);
  if (keys_key != "") NWNXPushString(keys_key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MONITOR() {
  NWNXPushString("MONITOR");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MOVE(
    string key,
    // Redis type: integer
    int db
) {
  NWNXPushString("MOVE");
  NWNXPushString(key);
  NWNXPushString(IntToString(db));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MSET(
    string key,
    string value
) {
  NWNXPushString("MSET");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MSETNX(
    string key,
    string value
) {
  NWNXPushString("MSETNX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int MULTI() {
  NWNXPushString("MULTI");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int OBJECT(
    string subcommand,
    string arguments = ""
) {
  NWNXPushString("OBJECT");
  NWNXPushString(subcommand);
  if (arguments != "") NWNXPushString(arguments);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PERSIST(
    string key
) {
  NWNXPushString("PERSIST");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PEXPIRE(
    string key,
    // Redis type: integer
    int milliseconds
) {
  NWNXPushString("PEXPIRE");
  NWNXPushString(key);
  NWNXPushString(IntToString(milliseconds));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PEXPIREAT(
    string key,
    // Redis type: posix time
    string milliseconds_timestamp
) {
  NWNXPushString("PEXPIREAT");
  NWNXPushString(key);
  NWNXPushString(milliseconds_timestamp);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PFADD(
    string key,
    string element
) {
  NWNXPushString("PFADD");
  NWNXPushString(key);
  NWNXPushString(element);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PFCOUNT(
    string key
) {
  NWNXPushString("PFCOUNT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PFMERGE(
    // Redis type: key
    string destkey,
    // Redis type: key
    string sourcekey
) {
  NWNXPushString("PFMERGE");
  NWNXPushString(destkey);
  NWNXPushString(sourcekey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PING(
    string message = ""
) {
  NWNXPushString("PING");
  if (message != "") NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PSETEX(
    string key,
    // Redis type: integer
    int milliseconds,
    string value
) {
  NWNXPushString("PSETEX");
  NWNXPushString(key);
  NWNXPushString(IntToString(milliseconds));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PUBSUB(
    string subcommand,
    string argument = ""
) {
  NWNXPushString("PUBSUB");
  NWNXPushString(subcommand);
  if (argument != "") NWNXPushString(argument);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PTTL(
    string key
) {
  NWNXPushString("PTTL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int PUBLISH(
    string channel,
    string message
) {
  NWNXPushString("PUBLISH");
  NWNXPushString(channel);
  NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int QUIT() {
  NWNXPushString("QUIT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RANDOMKEY() {
  NWNXPushString("RANDOMKEY");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int READONLY() {
  NWNXPushString("READONLY");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int READWRITE() {
  NWNXPushString("READWRITE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RENAME(
    string key,
    // Redis type: key
    string newkey
) {
  NWNXPushString("RENAME");
  NWNXPushString(key);
  NWNXPushString(newkey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RENAMENX(
    string key,
    // Redis type: key
    string newkey
) {
  NWNXPushString("RENAMENX");
  NWNXPushString(key);
  NWNXPushString(newkey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RESTORE(
    string key,
    // Redis type: integer
    int ttl,
    string serialized_value,
    // Redis type: enum
    string replace = "",
    // Redis type: enum
    string absttl = "",
    // Redis type: integer
    int idletime_seconds = 0,
    // Redis type: integer
    int freq_frequency = 0
) {
  NWNXPushString("RESTORE");
  NWNXPushString(key);
  NWNXPushString(IntToString(ttl));
  NWNXPushString(serialized_value);
  if (replace != "") NWNXPushString(replace);
  if (absttl != "") NWNXPushString(absttl);
  if (idletime_seconds != 0) NWNXPushString(IntToString(idletime_seconds));
  if (freq_frequency != 0) NWNXPushString(IntToString(freq_frequency));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ROLE() {
  NWNXPushString("ROLE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RPOP(
    string key
) {
  NWNXPushString("RPOP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination
) {
  NWNXPushString("RPOPLPUSH");
  NWNXPushString(source);
  NWNXPushString(destination);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RPUSH(
    string key,
    string value
) {
  NWNXPushString("RPUSH");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int RPUSHX(
    string key,
    string value
) {
  NWNXPushString("RPUSHX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SADD(
    string key,
    string member
) {
  NWNXPushString("SADD");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SAVE() {
  NWNXPushString("SAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCARD(
    string key
) {
  NWNXPushString("SCARD");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCRIPT_DEBUG(
    // Redis type: enum
    string mode
) {
  NWNXPushString("SCRIPT_DEBUG");
  NWNXPushString(mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCRIPT_EXISTS(
    string sha1
) {
  NWNXPushString("SCRIPT_EXISTS");
  NWNXPushString(sha1);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCRIPT_FLUSH() {
  NWNXPushString("SCRIPT_FLUSH");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCRIPT_KILL() {
  NWNXPushString("SCRIPT_KILL");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCRIPT_LOAD(
    string script
) {
  NWNXPushString("SCRIPT_LOAD");
  NWNXPushString(script);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SDIFF(
    string key
) {
  NWNXPushString("SDIFF");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SDIFFSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SDIFFSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SELECT(
    // Redis type: integer
    int index
) {
  NWNXPushString("SELECT");
  NWNXPushString(IntToString(index));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SET(
    string key,
    string value,
    // Redis type: enum
    string condition = ""
) {
  NWNXPushString("SET");
  NWNXPushString(key);
  NWNXPushString(value);
  if (condition != "") NWNXPushString(condition);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SETBIT(
    string key,
    // Redis type: integer
    int offset,
    string value
) {
  NWNXPushString("SETBIT");
  NWNXPushString(key);
  NWNXPushString(IntToString(offset));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SETEX(
    string key,
    // Redis type: integer
    int seconds,
    string value
) {
  NWNXPushString("SETEX");
  NWNXPushString(key);
  NWNXPushString(IntToString(seconds));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SETNX(
    string key,
    string value
) {
  NWNXPushString("SETNX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SETRANGE(
    string key,
    // Redis type: integer
    int offset,
    string value
) {
  NWNXPushString("SETRANGE");
  NWNXPushString(key);
  NWNXPushString(IntToString(offset));
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SHUTDOWN(
    // Redis type: enum
    string save_mode = ""
) {
  NWNXPushString("SHUTDOWN");
  if (save_mode != "") NWNXPushString(save_mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SINTER(
    string key
) {
  NWNXPushString("SINTER");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SINTERSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SINTERSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SISMEMBER(
    string key,
    string member
) {
  NWNXPushString("SISMEMBER");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SLAVEOF(
    string host,
    string port
) {
  NWNXPushString("SLAVEOF");
  NWNXPushString(host);
  NWNXPushString(port);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int REPLICAOF(
    string host,
    string port
) {
  NWNXPushString("REPLICAOF");
  NWNXPushString(host);
  NWNXPushString(port);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SLOWLOG(
    string subcommand,
    string argument = ""
) {
  NWNXPushString("SLOWLOG");
  NWNXPushString(subcommand);
  if (argument != "") NWNXPushString(argument);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SMEMBERS(
    string key
) {
  NWNXPushString("SMEMBERS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SMOVE(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    string member
) {
  NWNXPushString("SMOVE");
  NWNXPushString(source);
  NWNXPushString(destination);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SORT(
    string key,
    // Redis type: pattern
    string by_pattern = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0,
    string get_pattern = "",
    // Redis type: enum
    string order = "",
    // Redis type: enum
    string sorting = "",
    // Redis type: key
    string store_destination = ""
) {
  NWNXPushString("SORT");
  NWNXPushString(key);
  if (by_pattern != "") NWNXPushString(by_pattern);
  if (limit_offset != 0) NWNXPushString(IntToString(limit_offset));
  if (limit_count != 0) NWNXPushString(IntToString(limit_count));
  if (get_pattern != "") NWNXPushString(get_pattern);
  if (order != "") NWNXPushString(order);
  if (sorting != "") NWNXPushString(sorting);
  if (store_destination != "") NWNXPushString(store_destination);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SPOP(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNXPushString("SPOP");
  NWNXPushString(key);
  if (count != 0) NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SRANDMEMBER(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNXPushString("SRANDMEMBER");
  NWNXPushString(key);
  if (count != 0) NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SREM(
    string key,
    string member
) {
  NWNXPushString("SREM");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int STRLEN(
    string key
) {
  NWNXPushString("STRLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SUNION(
    string key
) {
  NWNXPushString("SUNION");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SUNIONSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SUNIONSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SWAPDB(
    // Redis type: integer
    int index,
    // Redis type: integer
    int index_1
) {
  NWNXPushString("SWAPDB");
  NWNXPushString(IntToString(index));
  NWNXPushString(IntToString(index_1));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SYNC() {
  NWNXPushString("SYNC");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int TIME() {
  NWNXPushString("TIME");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int TOUCH(
    string key
) {
  NWNXPushString("TOUCH");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int TTL(
    string key
) {
  NWNXPushString("TTL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int TYPE(
    string key
) {
  NWNXPushString("TYPE");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int UNLINK(
    string key
) {
  NWNXPushString("UNLINK");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int UNWATCH() {
  NWNXPushString("UNWATCH");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int WAIT(
    // Redis type: integer
    int numreplicas,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("WAIT");
  NWNXPushString(IntToString(numreplicas));
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int WATCH(
    string key
) {
  NWNXPushString("WATCH");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZADD(
    string key,
    // Redis type: enum
    string condition = "",
    // Redis type: enum
    string change = "",
    // Redis type: enum
    string increment = "",
    // Redis type: double
    float score = 0.0,
    string member = ""
) {
  NWNXPushString("ZADD");
  NWNXPushString(key);
  if (condition != "") NWNXPushString(condition);
  if (change != "") NWNXPushString(change);
  if (increment != "") NWNXPushString(increment);
  NWNXPushString(FloatToString(score, 0));
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZCARD(
    string key
) {
  NWNXPushString("ZCARD");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZCOUNT(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
) {
  NWNXPushString("ZCOUNT");
  NWNXPushString(key);
  NWNXPushString(FloatToString(min, 0));
  NWNXPushString(FloatToString(max, 0));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZINCRBY(
    string key,
    // Redis type: integer
    int increment,
    string member
) {
  NWNXPushString("ZINCRBY");
  NWNXPushString(key);
  NWNXPushString(IntToString(increment));
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZINTERSTORE(
    // Redis type: key
    string destination,
    // Redis type: integer
    int numkeys,
    string key,
    // Redis type: integer
    int weights_weight = 0,
    // Redis type: enum
    string aggregate_aggregate = ""
) {
  NWNXPushString("ZINTERSTORE");
  NWNXPushString(destination);
  NWNXPushString(IntToString(numkeys));
  NWNXPushString(key);
  if (weights_weight != 0) NWNXPushString(IntToString(weights_weight));
  if (aggregate_aggregate != "") NWNXPushString(aggregate_aggregate);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZLEXCOUNT(
    string key,
    string min,
    string max
) {
  NWNXPushString("ZLEXCOUNT");
  NWNXPushString(key);
  NWNXPushString(min);
  NWNXPushString(max);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZPOPMAX(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNXPushString("ZPOPMAX");
  NWNXPushString(key);
  if (count != 0) NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZPOPMIN(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNXPushString("ZPOPMIN");
  NWNXPushString(key);
  if (count != 0) NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
) {
  NWNXPushString("ZRANGE");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(stop));
  if (withscores != "") NWNXPushString(withscores);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZRANGEBYLEX(
    string key,
    string min,
    string max,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNXPushString("ZRANGEBYLEX");
  NWNXPushString(key);
  NWNXPushString(min);
  NWNXPushString(max);
  if (limit_offset != 0) NWNXPushString(IntToString(limit_offset));
  if (limit_count != 0) NWNXPushString(IntToString(limit_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREVRANGEBYLEX(
    string key,
    string max,
    string min,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNXPushString("ZREVRANGEBYLEX");
  NWNXPushString(key);
  NWNXPushString(max);
  NWNXPushString(min);
  if (limit_offset != 0) NWNXPushString(IntToString(limit_offset));
  if (limit_count != 0) NWNXPushString(IntToString(limit_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max,
    // Redis type: enum
    string withscores = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNXPushString("ZRANGEBYSCORE");
  NWNXPushString(key);
  NWNXPushString(FloatToString(min, 0));
  NWNXPushString(FloatToString(max, 0));
  if (withscores != "") NWNXPushString(withscores);
  if (limit_offset != 0) NWNXPushString(IntToString(limit_offset));
  if (limit_count != 0) NWNXPushString(IntToString(limit_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZRANK(
    string key,
    string member
) {
  NWNXPushString("ZRANK");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREM(
    string key,
    string member
) {
  NWNXPushString("ZREM");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREMRANGEBYLEX(
    string key,
    string min,
    string max
) {
  NWNXPushString("ZREMRANGEBYLEX");
  NWNXPushString(key);
  NWNXPushString(min);
  NWNXPushString(max);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREMRANGEBYRANK(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNXPushString("ZREMRANGEBYRANK");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(stop));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREMRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
) {
  NWNXPushString("ZREMRANGEBYSCORE");
  NWNXPushString(key);
  NWNXPushString(FloatToString(min, 0));
  NWNXPushString(FloatToString(max, 0));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREVRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
) {
  NWNXPushString("ZREVRANGE");
  NWNXPushString(key);
  NWNXPushString(IntToString(start));
  NWNXPushString(IntToString(stop));
  if (withscores != "") NWNXPushString(withscores);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREVRANGEBYSCORE(
    string key,
    // Redis type: double
    float max,
    // Redis type: double
    float min,
    // Redis type: enum
    string withscores = "",
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNXPushString("ZREVRANGEBYSCORE");
  NWNXPushString(key);
  NWNXPushString(FloatToString(max, 0));
  NWNXPushString(FloatToString(min, 0));
  if (withscores != "") NWNXPushString(withscores);
  if (limit_offset != 0) NWNXPushString(IntToString(limit_offset));
  if (limit_count != 0) NWNXPushString(IntToString(limit_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZREVRANK(
    string key,
    string member
) {
  NWNXPushString("ZREVRANK");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZSCORE(
    string key,
    string member
) {
  NWNXPushString("ZSCORE");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZUNIONSTORE(
    // Redis type: key
    string destination,
    // Redis type: integer
    int numkeys,
    string key,
    // Redis type: integer
    int weights_weight = 0,
    // Redis type: enum
    string aggregate_aggregate = ""
) {
  NWNXPushString("ZUNIONSTORE");
  NWNXPushString(destination);
  NWNXPushString(IntToString(numkeys));
  NWNXPushString(key);
  if (weights_weight != 0) NWNXPushString(IntToString(weights_weight));
  if (aggregate_aggregate != "") NWNXPushString(aggregate_aggregate);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SCAN(
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0,
    string type_type = ""
) {
  NWNXPushString("SCAN");
  NWNXPushString(IntToString(cursor));
  if (match_pattern != "") NWNXPushString(match_pattern);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  if (type_type != "") NWNXPushString(type_type);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int SSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNXPushString("SSCAN");
  NWNXPushString(key);
  NWNXPushString(IntToString(cursor));
  if (match_pattern != "") NWNXPushString(match_pattern);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int HSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNXPushString("HSCAN");
  NWNXPushString(key);
  NWNXPushString(IntToString(cursor));
  if (match_pattern != "") NWNXPushString(match_pattern);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int ZSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNXPushString("ZSCAN");
  NWNXPushString(key);
  NWNXPushString(IntToString(cursor));
  if (match_pattern != "") NWNXPushString(match_pattern);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XINFO(
    // Redis type: key
    string consumers_key = "",
    string consumers_groupname = "",
    // Redis type: key
    string groups_key = "",
    // Redis type: key
    string stream_key = "",
    // Redis type: enum
    string help = ""
) {
  NWNXPushString("XINFO");
  if (consumers_key != "") NWNXPushString(consumers_key);
  if (consumers_groupname != "") NWNXPushString(consumers_groupname);
  if (groups_key != "") NWNXPushString(groups_key);
  if (stream_key != "") NWNXPushString(stream_key);
  if (help != "") NWNXPushString(help);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XADD(
    string key,
    string ID,
    // Redis type: value
    string field,
    string str
) {
  NWNXPushString("XADD");
  NWNXPushString(key);
  NWNXPushString(ID);
  NWNXPushString(field);
  NWNXPushString(str);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XTRIM(
    string key,
    // Redis type: enum
    string strategy,
    // Redis type: enum
    string approx = "",
    // Redis type: integer
    int count = 0
) {
  NWNXPushString("XTRIM");
  NWNXPushString(key);
  NWNXPushString(strategy);
  if (approx != "") NWNXPushString(approx);
  NWNXPushString(IntToString(count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XDEL(
    string key,
    string ID
) {
  NWNXPushString("XDEL");
  NWNXPushString(key);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XRANGE(
    string key,
    string start,
    string end,
    // Redis type: integer
    int count_count = 0
) {
  NWNXPushString("XRANGE");
  NWNXPushString(key);
  NWNXPushString(start);
  NWNXPushString(end);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XREVRANGE(
    string key,
    string end,
    string start,
    // Redis type: integer
    int count_count = 0
) {
  NWNXPushString("XREVRANGE");
  NWNXPushString(key);
  NWNXPushString(end);
  NWNXPushString(start);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XLEN(
    string key
) {
  NWNXPushString("XLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XREAD(
    // Redis type: integer
    int count_count = 0,
    // Redis type: integer
    int block_milliseconds = 0,
    // Redis type: enum
    string streams = "",
    string key = "",
    string ID = ""
) {
  NWNXPushString("XREAD");
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  if (block_milliseconds != 0) NWNXPushString(IntToString(block_milliseconds));
  NWNXPushString(streams);
  NWNXPushString(key);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XGROUP(
    // Redis type: key
    string create_key = "",
    string create_groupname = "",
    string create_id_or__ = "",
    // Redis type: key
    string setid_key = "",
    string setid_groupname = "",
    string setid_id_or__ = "",
    // Redis type: key
    string destroy_key = "",
    string destroy_groupname = "",
    // Redis type: key
    string delconsumer_key = "",
    string delconsumer_groupname = "",
    string delconsumer_consumername = ""
) {
  NWNXPushString("XGROUP");
  if (create_key != "") NWNXPushString(create_key);
  if (create_groupname != "") NWNXPushString(create_groupname);
  if (create_id_or__ != "") NWNXPushString(create_id_or__);
  if (setid_key != "") NWNXPushString(setid_key);
  if (setid_groupname != "") NWNXPushString(setid_groupname);
  if (setid_id_or__ != "") NWNXPushString(setid_id_or__);
  if (destroy_key != "") NWNXPushString(destroy_key);
  if (destroy_groupname != "") NWNXPushString(destroy_groupname);
  if (delconsumer_key != "") NWNXPushString(delconsumer_key);
  if (delconsumer_groupname != "") NWNXPushString(delconsumer_groupname);
  if (delconsumer_consumername != "") NWNXPushString(delconsumer_consumername);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XREADGROUP(
    string group_group,
    string group_consumer,
    // Redis type: integer
    int count_count = 0,
    // Redis type: integer
    int block_milliseconds = 0,
    // Redis type: enum
    string noack = "",
    // Redis type: enum
    string streams = "",
    string key = "",
    string ID = ""
) {
  NWNXPushString("XREADGROUP");
  NWNXPushString(group_group);
  NWNXPushString(group_consumer);
  if (count_count != 0) NWNXPushString(IntToString(count_count));
  if (block_milliseconds != 0) NWNXPushString(IntToString(block_milliseconds));
  if (noack != "") NWNXPushString(noack);
  NWNXPushString(streams);
  NWNXPushString(key);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XACK(
    string key,
    string group,
    string ID
) {
  NWNXPushString("XACK");
  NWNXPushString(key);
  NWNXPushString(group);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XCLAIM(
    string key,
    string group,
    string consumer,
    string min_idle_time,
    string ID,
    // Redis type: integer
    int idle_ms = 0,
    // Redis type: integer
    int time_ms_unix_time = 0,
    // Redis type: integer
    int retrycount_count = 0
) {
  NWNXPushString("XCLAIM");
  NWNXPushString(key);
  NWNXPushString(group);
  NWNXPushString(consumer);
  NWNXPushString(min_idle_time);
  NWNXPushString(ID);
  if (idle_ms != 0) NWNXPushString(IntToString(idle_ms));
  if (time_ms_unix_time != 0) NWNXPushString(IntToString(time_ms_unix_time));
  if (retrycount_count != 0) NWNXPushString(IntToString(retrycount_count));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int XPENDING(
    string key,
    string group,
    string start = "",
    string end = "",
    // Redis type: integer
    int count = 0,
    string consumer = ""
) {
  NWNXPushString("XPENDING");
  NWNXPushString(key);
  NWNXPushString(group);
  if (start != "") NWNXPushString(start);
  if (end != "") NWNXPushString(end);
  if (count != 0) NWNXPushString(IntToString(count));
  if (consumer != "") NWNXPushString(consumer);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}