nwnx_redis.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 NWNX_Redis_APPEND(
    string key,
    string value
);
 
int NWNX_Redis_AUTH(
    string password
);
 
int NWNX_Redis_BGREWRITEAOF();
 
int NWNX_Redis_BGSAVE();
 
int NWNX_Redis_BITCOUNT(
    string key,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
);
 
int NWNX_Redis_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 NWNX_Redis_BITOP(
    string operation,
    // Redis type: key
    string destkey,
    string key
);
 
int NWNX_Redis_BITPOS(
    string key,
    // Redis type: integer
    int bit,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
);
 
int NWNX_Redis_BLPOP(
    string key,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_BRPOP(
    string key,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_BRPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_BZPOPMIN(
    string key,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_BZPOPMAX(
    string key,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_CLIENT_ID();
 
int NWNX_Redis_CLIENT_KILL(
    string ip_port = "",
    // Redis type: integer
    int id_client_id = 0,
    string addr_ip_port = "",
    string skipme_yes_no = ""
);
 
int NWNX_Redis_CLIENT_LIST();
 
int NWNX_Redis_CLIENT_GETNAME();
 
int NWNX_Redis_CLIENT_PAUSE(
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_CLIENT_REPLY(
    // Redis type: enum
    string reply_mode
);
 
int NWNX_Redis_CLIENT_SETNAME(
    string connection_name
);
 
int NWNX_Redis_CLIENT_UNBLOCK(
    string client_id,
    // Redis type: enum
    string unblock_type = ""
);
 
int NWNX_Redis_CLUSTER_ADDSLOTS(
    // Redis type: integer
    int slot
);
 
int NWNX_Redis_CLUSTER_COUNT_FAILURE_REPORTS(
    string node_id
);
 
int NWNX_Redis_CLUSTER_COUNTKEYSINSLOT(
    // Redis type: integer
    int slot
);
 
int NWNX_Redis_CLUSTER_DELSLOTS(
    // Redis type: integer
    int slot
);
 
int NWNX_Redis_CLUSTER_FAILOVER(
    // Redis type: enum
    string options = ""
);
 
int NWNX_Redis_CLUSTER_FORGET(
    string node_id
);
 
int NWNX_Redis_CLUSTER_GETKEYSINSLOT(
    // Redis type: integer
    int slot,
    // Redis type: integer
    int count
);
 
int NWNX_Redis_CLUSTER_INFO();
 
int NWNX_Redis_CLUSTER_KEYSLOT(
    string key
);
 
int NWNX_Redis_CLUSTER_MEET(
    string ip,
    // Redis type: integer
    int port
);
 
int NWNX_Redis_CLUSTER_NODES();
 
int NWNX_Redis_CLUSTER_REPLICATE(
    string node_id
);
 
int NWNX_Redis_CLUSTER_RESET(
    // Redis type: enum
    string reset_type = ""
);
 
int NWNX_Redis_CLUSTER_SAVECONFIG();
 
int NWNX_Redis_CLUSTER_SET_CONFIG_EPOCH(
    // Redis type: integer
    int config_epoch
);
 
int NWNX_Redis_CLUSTER_SETSLOT(
    // Redis type: integer
    int slot,
    // Redis type: enum
    string subcommand,
    string node_id = ""
);
 
int NWNX_Redis_CLUSTER_SLAVES(
    string node_id
);
 
int NWNX_Redis_CLUSTER_REPLICAS(
    string node_id
);
 
int NWNX_Redis_CLUSTER_SLOTS();
 
int NWNX_Redis_COMMAND();
 
int NWNX_Redis_COMMAND_COUNT();
 
int NWNX_Redis_COMMAND_GETKEYS();
 
int NWNX_Redis_COMMAND_INFO(
    string command_name
);
 
int NWNX_Redis_CONFIG_GET(
    string parameter
);
 
int NWNX_Redis_CONFIG_REWRITE();
 
int NWNX_Redis_CONFIG_SET(
    string parameter,
    string value
);
 
int NWNX_Redis_CONFIG_RESETSTAT();
 
int NWNX_Redis_DBSIZE();
 
int NWNX_Redis_DEBUG_OBJECT(
    string key
);
 
int NWNX_Redis_DEBUG_SEGFAULT();
 
int NWNX_Redis_DECR(
    string key
);
 
int NWNX_Redis_DECRBY(
    string key,
    // Redis type: integer
    int decrement
);
 
int NWNX_Redis_DEL(
    string key
);
 
int NWNX_Redis_DISCARD();
 
int NWNX_Redis_DUMP(
    string key
);
 
int NWNX_Redis_ECHO(
    string message
);
 
int NWNX_Redis_EVAL(
    string script,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
);
 
int NWNX_Redis_EVALSHA(
    string sha1,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
);
 
int NWNX_Redis_EXEC();
 
int NWNX_Redis_EXISTS(
    string key
);
 
int NWNX_Redis_EXPIRE(
    string key,
    // Redis type: integer
    int seconds
);
 
int NWNX_Redis_EXPIREAT(
    string key,
    // Redis type: posix time
    string timestamp
);
 
int NWNX_Redis_FLUSHALL(
    // Redis type: enum
    string async = ""
);
 
int NWNX_Redis_FLUSHDB(
    // Redis type: enum
    string async = ""
);
 
int NWNX_Redis_GEOADD(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    string member
);
 
int NWNX_Redis_GEOHASH(
    string key,
    string member
);
 
int NWNX_Redis_GEOPOS(
    string key,
    string member
);
 
int NWNX_Redis_GEODIST(
    string key,
    string member1,
    string member2,
    string unit = ""
);
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_GET(
    string key
);
 
int NWNX_Redis_GETBIT(
    string key,
    // Redis type: integer
    int offset
);
 
int NWNX_Redis_GETRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int end
);
 
int NWNX_Redis_GETSET(
    string key,
    string value
);
 
int NWNX_Redis_HDEL(
    string key,
    string field
);
 
int NWNX_Redis_HEXISTS(
    string key,
    string field
);
 
int NWNX_Redis_HGET(
    string key,
    string field
);
 
int NWNX_Redis_HGETALL(
    string key
);
 
int NWNX_Redis_HINCRBY(
    string key,
    string field,
    // Redis type: integer
    int increment
);
 
int NWNX_Redis_HINCRBYFLOAT(
    string key,
    string field,
    // Redis type: double
    float increment
);
 
int NWNX_Redis_HKEYS(
    string key
);
 
int NWNX_Redis_HLEN(
    string key
);
 
int NWNX_Redis_HMGET(
    string key,
    string field
);
 
int NWNX_Redis_HMSET(
    string key,
    string field,
    string value
);
 
int NWNX_Redis_HSET(
    string key,
    string field,
    string value
);
 
int NWNX_Redis_HSETNX(
    string key,
    string field,
    string value
);
 
int NWNX_Redis_HSTRLEN(
    string key,
    string field
);
 
int NWNX_Redis_HVALS(
    string key
);
 
int NWNX_Redis_INCR(
    string key
);
 
int NWNX_Redis_INCRBY(
    string key,
    // Redis type: integer
    int increment
);
 
int NWNX_Redis_INCRBYFLOAT(
    string key,
    // Redis type: double
    float increment
);
 
int NWNX_Redis_INFO(
    string section = ""
);
 
int NWNX_Redis_KEYS(
    string pattern
);
 
int NWNX_Redis_LASTSAVE();
 
int NWNX_Redis_LINDEX(
    string key,
    // Redis type: integer
    int index
);
 
int NWNX_Redis_LINSERT(
    string key,
    // Redis type: enum
    string where,
    string pivot,
    string value
);
 
int NWNX_Redis_LLEN(
    string key
);
 
int NWNX_Redis_LPOP(
    string key
);
 
int NWNX_Redis_LPUSH(
    string key,
    string value
);
 
int NWNX_Redis_LPUSHX(
    string key,
    string value
);
 
int NWNX_Redis_LRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int NWNX_Redis_LREM(
    string key,
    // Redis type: integer
    int count,
    string value
);
 
int NWNX_Redis_LSET(
    string key,
    // Redis type: integer
    int index,
    string value
);
 
int NWNX_Redis_LTRIM(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int NWNX_Redis_MEMORY_DOCTOR();
 
int NWNX_Redis_MEMORY_HELP();
 
int NWNX_Redis_MEMORY_MALLOC_STATS();
 
int NWNX_Redis_MEMORY_PURGE();
 
int NWNX_Redis_MEMORY_STATS();
 
int NWNX_Redis_MEMORY_USAGE(
    string key,
    // Redis type: integer
    int samples_count = 0
);
 
int NWNX_Redis_MGET(
    string key
);
 
int NWNX_Redis_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 NWNX_Redis_MONITOR();
 
int NWNX_Redis_MOVE(
    string key,
    // Redis type: integer
    int db
);
 
int NWNX_Redis_MSET(
    string key,
    string value
);
 
int NWNX_Redis_MSETNX(
    string key,
    string value
);
 
int NWNX_Redis_MULTI();
 
int NWNX_Redis_OBJECT(
    string subcommand,
    string arguments = ""
);
 
int NWNX_Redis_PERSIST(
    string key
);
 
int NWNX_Redis_PEXPIRE(
    string key,
    // Redis type: integer
    int milliseconds
);
 
int NWNX_Redis_PEXPIREAT(
    string key,
    // Redis type: posix time
    string milliseconds_timestamp
);
 
int NWNX_Redis_PFADD(
    string key,
    string element
);
 
int NWNX_Redis_PFCOUNT(
    string key
);
 
int NWNX_Redis_PFMERGE(
    // Redis type: key
    string destkey,
    // Redis type: key
    string sourcekey
);
 
int NWNX_Redis_PING(
    string message = ""
);
 
int NWNX_Redis_PSETEX(
    string key,
    // Redis type: integer
    int milliseconds,
    string value
);
 
int NWNX_Redis_PUBSUB(
    string subcommand,
    string argument = ""
);
 
int NWNX_Redis_PTTL(
    string key
);
 
int NWNX_Redis_PUBLISH(
    string channel,
    string message
);
 
int NWNX_Redis_QUIT();
 
int NWNX_Redis_RANDOMKEY();
 
int NWNX_Redis_READONLY();
 
int NWNX_Redis_READWRITE();
 
int NWNX_Redis_RENAME(
    string key,
    // Redis type: key
    string newkey
);
 
int NWNX_Redis_RENAMENX(
    string key,
    // Redis type: key
    string newkey
);
 
int NWNX_Redis_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 NWNX_Redis_ROLE();
 
int NWNX_Redis_RPOP(
    string key
);
 
int NWNX_Redis_RPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination
);
 
int NWNX_Redis_RPUSH(
    string key,
    string value
);
 
int NWNX_Redis_RPUSHX(
    string key,
    string value
);
 
int NWNX_Redis_SADD(
    string key,
    string member
);
 
int NWNX_Redis_SAVE();
 
int NWNX_Redis_SCARD(
    string key
);
 
int NWNX_Redis_SCRIPT_DEBUG(
    // Redis type: enum
    string mode
);
 
int NWNX_Redis_SCRIPT_EXISTS(
    string sha1
);
 
int NWNX_Redis_SCRIPT_FLUSH();
 
int NWNX_Redis_SCRIPT_KILL();
 
int NWNX_Redis_SCRIPT_LOAD(
    string script
);
 
int NWNX_Redis_SDIFF(
    string key
);
 
int NWNX_Redis_SDIFFSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int NWNX_Redis_SELECT(
    // Redis type: integer
    int index
);
 
int NWNX_Redis_SET(
    string key,
    string value,
    // Redis type: enum
    string condition = ""
);
 
int NWNX_Redis_SETBIT(
    string key,
    // Redis type: integer
    int offset,
    string value
);
 
int NWNX_Redis_SETEX(
    string key,
    // Redis type: integer
    int seconds,
    string value
);
 
int NWNX_Redis_SETNX(
    string key,
    string value
);
 
int NWNX_Redis_SETRANGE(
    string key,
    // Redis type: integer
    int offset,
    string value
);
 
int NWNX_Redis_SHUTDOWN(
    // Redis type: enum
    string save_mode = ""
);
 
int NWNX_Redis_SINTER(
    string key
);
 
int NWNX_Redis_SINTERSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int NWNX_Redis_SISMEMBER(
    string key,
    string member
);
 
int NWNX_Redis_SLAVEOF(
    string host,
    string port
);
 
int NWNX_Redis_REPLICAOF(
    string host,
    string port
);
 
int NWNX_Redis_SLOWLOG(
    string subcommand,
    string argument = ""
);
 
int NWNX_Redis_SMEMBERS(
    string key
);
 
int NWNX_Redis_SMOVE(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    string member
);
 
int NWNX_Redis_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 NWNX_Redis_SPOP(
    string key,
    // Redis type: integer
    int count = 0
);
 
int NWNX_Redis_SRANDMEMBER(
    string key,
    // Redis type: integer
    int count = 0
);
 
int NWNX_Redis_SREM(
    string key,
    string member
);
 
int NWNX_Redis_STRLEN(
    string key
);
 
int NWNX_Redis_SUNION(
    string key
);
 
int NWNX_Redis_SUNIONSTORE(
    // Redis type: key
    string destination,
    string key
);
 
int NWNX_Redis_SWAPDB(
    // Redis type: integer
    int index,
    // Redis type: integer
    int index_1
);
 
int NWNX_Redis_SYNC();
 
int NWNX_Redis_TIME();
 
int NWNX_Redis_TOUCH(
    string key
);
 
int NWNX_Redis_TTL(
    string key
);
 
int NWNX_Redis_TYPE(
    string key
);
 
int NWNX_Redis_UNLINK(
    string key
);
 
int NWNX_Redis_UNWATCH();
 
int NWNX_Redis_WAIT(
    // Redis type: integer
    int numreplicas,
    // Redis type: integer
    int timeout
);
 
int NWNX_Redis_WATCH(
    string key
);
 
int NWNX_Redis_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 NWNX_Redis_ZCARD(
    string key
);
 
int NWNX_Redis_ZCOUNT(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
);
 
int NWNX_Redis_ZINCRBY(
    string key,
    // Redis type: integer
    int increment,
    string member
);
 
int NWNX_Redis_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 NWNX_Redis_ZLEXCOUNT(
    string key,
    string min,
    string max
);
 
int NWNX_Redis_ZPOPMAX(
    string key,
    // Redis type: integer
    int count = 0
);
 
int NWNX_Redis_ZPOPMIN(
    string key,
    // Redis type: integer
    int count = 0
);
 
int NWNX_Redis_ZRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
);
 
int NWNX_Redis_ZRANGEBYLEX(
    string key,
    string min,
    string max,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int NWNX_Redis_ZREVRANGEBYLEX(
    string key,
    string max,
    string min,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
);
 
int NWNX_Redis_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 NWNX_Redis_ZRANK(
    string key,
    string member
);
 
int NWNX_Redis_ZREM(
    string key,
    string member
);
 
int NWNX_Redis_ZREMRANGEBYLEX(
    string key,
    string min,
    string max
);
 
int NWNX_Redis_ZREMRANGEBYRANK(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
);
 
int NWNX_Redis_ZREMRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
);
 
int NWNX_Redis_ZREVRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
);
 
int NWNX_Redis_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 NWNX_Redis_ZREVRANK(
    string key,
    string member
);
 
int NWNX_Redis_ZSCORE(
    string key,
    string member
);
 
int NWNX_Redis_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 NWNX_Redis_SCAN(
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0,
    string type_type = ""
);
 
int NWNX_Redis_SSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int NWNX_Redis_HSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int NWNX_Redis_ZSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
);
 
int NWNX_Redis_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 NWNX_Redis_XADD(
    string key,
    string ID,
    // Redis type: value
    string field,
    string str
);
 
int NWNX_Redis_XTRIM(
    string key,
    // Redis type: enum
    string strategy,
    // Redis type: enum
    string approx = "",
    // Redis type: integer
    int count = 0
);
 
int NWNX_Redis_XDEL(
    string key,
    string ID
);
 
int NWNX_Redis_XRANGE(
    string key,
    string start,
    string end,
    // Redis type: integer
    int count_count = 0
);
 
int NWNX_Redis_XREVRANGE(
    string key,
    string end,
    string start,
    // Redis type: integer
    int count_count = 0
);
 
int NWNX_Redis_XLEN(
    string key
);
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_XACK(
    string key,
    string group,
    string ID
);
 
int NWNX_Redis_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 NWNX_Redis_XPENDING(
    string key,
    string group,
    string start = "",
    string end = "",
    // Redis type: integer
    int count = 0,
    string consumer = ""
);
 
 
 
// Implementation below
int NWNX_Redis_APPEND(
    string key,
    string value
) {
  NWNXPushString("APPEND");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_AUTH(
    string password
) {
  NWNXPushString("AUTH");
  NWNXPushString(password);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_BGREWRITEAOF() {
  NWNXPushString("BGREWRITEAOF");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_BGSAVE() {
  NWNXPushString("BGSAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_BLPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BLPOP");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_BRPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BRPOP");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_BZPOPMIN(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BZPOPMIN");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_BZPOPMAX(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNXPushString("BZPOPMAX");
  NWNXPushString(key);
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLIENT_ID() {
  NWNXPushString("CLIENT_ID");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_CLIENT_LIST() {
  NWNXPushString("CLIENT_LIST");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLIENT_GETNAME() {
  NWNXPushString("CLIENT_GETNAME");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLIENT_PAUSE(
    // Redis type: integer
    int timeout
) {
  NWNXPushString("CLIENT_PAUSE");
  NWNXPushString(IntToString(timeout));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLIENT_REPLY(
    // Redis type: enum
    string reply_mode
) {
  NWNXPushString("CLIENT_REPLY");
  NWNXPushString(reply_mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLIENT_SETNAME(
    string connection_name
) {
  NWNXPushString("CLIENT_SETNAME");
  NWNXPushString(connection_name);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_CLUSTER_ADDSLOTS(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_ADDSLOTS");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_COUNT_FAILURE_REPORTS(
    string node_id
) {
  NWNXPushString("CLUSTER_COUNT_FAILURE_REPORTS");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_COUNTKEYSINSLOT(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_COUNTKEYSINSLOT");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_DELSLOTS(
    // Redis type: integer
    int slot
) {
  NWNXPushString("CLUSTER_DELSLOTS");
  NWNXPushString(IntToString(slot));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_FAILOVER(
    // Redis type: enum
    string options = ""
) {
  NWNXPushString("CLUSTER_FAILOVER");
  if (options != "") NWNXPushString(options);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_FORGET(
    string node_id
) {
  NWNXPushString("CLUSTER_FORGET");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_CLUSTER_INFO() {
  NWNXPushString("CLUSTER_INFO");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_KEYSLOT(
    string key
) {
  NWNXPushString("CLUSTER_KEYSLOT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_MEET(
    string ip,
    // Redis type: integer
    int port
) {
  NWNXPushString("CLUSTER_MEET");
  NWNXPushString(ip);
  NWNXPushString(IntToString(port));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_NODES() {
  NWNXPushString("CLUSTER_NODES");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_REPLICATE(
    string node_id
) {
  NWNXPushString("CLUSTER_REPLICATE");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_RESET(
    // Redis type: enum
    string reset_type = ""
) {
  NWNXPushString("CLUSTER_RESET");
  if (reset_type != "") NWNXPushString(reset_type);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_SAVECONFIG() {
  NWNXPushString("CLUSTER_SAVECONFIG");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_CLUSTER_SLAVES(
    string node_id
) {
  NWNXPushString("CLUSTER_SLAVES");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_REPLICAS(
    string node_id
) {
  NWNXPushString("CLUSTER_REPLICAS");
  NWNXPushString(node_id);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CLUSTER_SLOTS() {
  NWNXPushString("CLUSTER_SLOTS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_COMMAND() {
  NWNXPushString("COMMAND");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_COMMAND_COUNT() {
  NWNXPushString("COMMAND_COUNT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_COMMAND_GETKEYS() {
  NWNXPushString("COMMAND_GETKEYS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_COMMAND_INFO(
    string command_name
) {
  NWNXPushString("COMMAND_INFO");
  NWNXPushString(command_name);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CONFIG_GET(
    string parameter
) {
  NWNXPushString("CONFIG_GET");
  NWNXPushString(parameter);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CONFIG_REWRITE() {
  NWNXPushString("CONFIG_REWRITE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CONFIG_SET(
    string parameter,
    string value
) {
  NWNXPushString("CONFIG_SET");
  NWNXPushString(parameter);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_CONFIG_RESETSTAT() {
  NWNXPushString("CONFIG_RESETSTAT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DBSIZE() {
  NWNXPushString("DBSIZE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DEBUG_OBJECT(
    string key
) {
  NWNXPushString("DEBUG_OBJECT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DEBUG_SEGFAULT() {
  NWNXPushString("DEBUG_SEGFAULT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DECR(
    string key
) {
  NWNXPushString("DECR");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DECRBY(
    string key,
    // Redis type: integer
    int decrement
) {
  NWNXPushString("DECRBY");
  NWNXPushString(key);
  NWNXPushString(IntToString(decrement));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DEL(
    string key
) {
  NWNXPushString("DEL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DISCARD() {
  NWNXPushString("DISCARD");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_DUMP(
    string key
) {
  NWNXPushString("DUMP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_ECHO(
    string message
) {
  NWNXPushString("ECHO");
  NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_EXEC() {
  NWNXPushString("EXEC");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_EXISTS(
    string key
) {
  NWNXPushString("EXISTS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_EXPIRE(
    string key,
    // Redis type: integer
    int seconds
) {
  NWNXPushString("EXPIRE");
  NWNXPushString(key);
  NWNXPushString(IntToString(seconds));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_EXPIREAT(
    string key,
    // Redis type: posix time
    string timestamp
) {
  NWNXPushString("EXPIREAT");
  NWNXPushString(key);
  NWNXPushString(timestamp);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_FLUSHALL(
    // Redis type: enum
    string async = ""
) {
  NWNXPushString("FLUSHALL");
  if (async != "") NWNXPushString(async);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_FLUSHDB(
    // Redis type: enum
    string async = ""
) {
  NWNXPushString("FLUSHDB");
  if (async != "") NWNXPushString(async);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_GEOHASH(
    string key,
    string member
) {
  NWNXPushString("GEOHASH");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_GEOPOS(
    string key,
    string member
) {
  NWNXPushString("GEOPOS");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_GET(
    string key
) {
  NWNXPushString("GET");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_GETBIT(
    string key,
    // Redis type: integer
    int offset
) {
  NWNXPushString("GETBIT");
  NWNXPushString(key);
  NWNXPushString(IntToString(offset));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_GETSET(
    string key,
    string value
) {
  NWNXPushString("GETSET");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HDEL(
    string key,
    string field
) {
  NWNXPushString("HDEL");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HEXISTS(
    string key,
    string field
) {
  NWNXPushString("HEXISTS");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HGET(
    string key,
    string field
) {
  NWNXPushString("HGET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HGETALL(
    string key
) {
  NWNXPushString("HGETALL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_HKEYS(
    string key
) {
  NWNXPushString("HKEYS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HLEN(
    string key
) {
  NWNXPushString("HLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HMGET(
    string key,
    string field
) {
  NWNXPushString("HMGET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HMSET(
    string key,
    string field,
    string value
) {
  NWNXPushString("HMSET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HSET(
    string key,
    string field,
    string value
) {
  NWNXPushString("HSET");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HSETNX(
    string key,
    string field,
    string value
) {
  NWNXPushString("HSETNX");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HSTRLEN(
    string key,
    string field
) {
  NWNXPushString("HSTRLEN");
  NWNXPushString(key);
  NWNXPushString(field);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_HVALS(
    string key
) {
  NWNXPushString("HVALS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_INCR(
    string key
) {
  NWNXPushString("INCR");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_INCRBY(
    string key,
    // Redis type: integer
    int increment
) {
  NWNXPushString("INCRBY");
  NWNXPushString(key);
  NWNXPushString(IntToString(increment));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_INCRBYFLOAT(
    string key,
    // Redis type: double
    float increment
) {
  NWNXPushString("INCRBYFLOAT");
  NWNXPushString(key);
  NWNXPushString(FloatToString(increment, 0));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_INFO(
    string section = ""
) {
  NWNXPushString("INFO");
  if (section != "") NWNXPushString(section);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_KEYS(
    string pattern
) {
  NWNXPushString("KEYS");
  NWNXPushString(pattern);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_LASTSAVE() {
  NWNXPushString("LASTSAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_LINDEX(
    string key,
    // Redis type: integer
    int index
) {
  NWNXPushString("LINDEX");
  NWNXPushString(key);
  NWNXPushString(IntToString(index));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_LLEN(
    string key
) {
  NWNXPushString("LLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_LPOP(
    string key
) {
  NWNXPushString("LPOP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_LPUSH(
    string key,
    string value
) {
  NWNXPushString("LPUSH");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_LPUSHX(
    string key,
    string value
) {
  NWNXPushString("LPUSHX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_MEMORY_DOCTOR() {
  NWNXPushString("MEMORY_DOCTOR");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MEMORY_HELP() {
  NWNXPushString("MEMORY_HELP");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MEMORY_MALLOC_STATS() {
  NWNXPushString("MEMORY_MALLOC_STATS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MEMORY_PURGE() {
  NWNXPushString("MEMORY_PURGE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MEMORY_STATS() {
  NWNXPushString("MEMORY_STATS");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_MGET(
    string key
) {
  NWNXPushString("MGET");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_MONITOR() {
  NWNXPushString("MONITOR");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MOVE(
    string key,
    // Redis type: integer
    int db
) {
  NWNXPushString("MOVE");
  NWNXPushString(key);
  NWNXPushString(IntToString(db));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MSET(
    string key,
    string value
) {
  NWNXPushString("MSET");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MSETNX(
    string key,
    string value
) {
  NWNXPushString("MSETNX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_MULTI() {
  NWNXPushString("MULTI");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_OBJECT(
    string subcommand,
    string arguments = ""
) {
  NWNXPushString("OBJECT");
  NWNXPushString(subcommand);
  if (arguments != "") NWNXPushString(arguments);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PERSIST(
    string key
) {
  NWNXPushString("PERSIST");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PEXPIRE(
    string key,
    // Redis type: integer
    int milliseconds
) {
  NWNXPushString("PEXPIRE");
  NWNXPushString(key);
  NWNXPushString(IntToString(milliseconds));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PEXPIREAT(
    string key,
    // Redis type: posix time
    string milliseconds_timestamp
) {
  NWNXPushString("PEXPIREAT");
  NWNXPushString(key);
  NWNXPushString(milliseconds_timestamp);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PFADD(
    string key,
    string element
) {
  NWNXPushString("PFADD");
  NWNXPushString(key);
  NWNXPushString(element);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PFCOUNT(
    string key
) {
  NWNXPushString("PFCOUNT");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PFMERGE(
    // Redis type: key
    string destkey,
    // Redis type: key
    string sourcekey
) {
  NWNXPushString("PFMERGE");
  NWNXPushString(destkey);
  NWNXPushString(sourcekey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PING(
    string message = ""
) {
  NWNXPushString("PING");
  if (message != "") NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_PUBSUB(
    string subcommand,
    string argument = ""
) {
  NWNXPushString("PUBSUB");
  NWNXPushString(subcommand);
  if (argument != "") NWNXPushString(argument);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PTTL(
    string key
) {
  NWNXPushString("PTTL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_PUBLISH(
    string channel,
    string message
) {
  NWNXPushString("PUBLISH");
  NWNXPushString(channel);
  NWNXPushString(message);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_QUIT() {
  NWNXPushString("QUIT");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RANDOMKEY() {
  NWNXPushString("RANDOMKEY");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_READONLY() {
  NWNXPushString("READONLY");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_READWRITE() {
  NWNXPushString("READWRITE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RENAME(
    string key,
    // Redis type: key
    string newkey
) {
  NWNXPushString("RENAME");
  NWNXPushString(key);
  NWNXPushString(newkey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RENAMENX(
    string key,
    // Redis type: key
    string newkey
) {
  NWNXPushString("RENAMENX");
  NWNXPushString(key);
  NWNXPushString(newkey);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_ROLE() {
  NWNXPushString("ROLE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RPOP(
    string key
) {
  NWNXPushString("RPOP");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination
) {
  NWNXPushString("RPOPLPUSH");
  NWNXPushString(source);
  NWNXPushString(destination);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RPUSH(
    string key,
    string value
) {
  NWNXPushString("RPUSH");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_RPUSHX(
    string key,
    string value
) {
  NWNXPushString("RPUSHX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SADD(
    string key,
    string member
) {
  NWNXPushString("SADD");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SAVE() {
  NWNXPushString("SAVE");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCARD(
    string key
) {
  NWNXPushString("SCARD");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCRIPT_DEBUG(
    // Redis type: enum
    string mode
) {
  NWNXPushString("SCRIPT_DEBUG");
  NWNXPushString(mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCRIPT_EXISTS(
    string sha1
) {
  NWNXPushString("SCRIPT_EXISTS");
  NWNXPushString(sha1);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCRIPT_FLUSH() {
  NWNXPushString("SCRIPT_FLUSH");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCRIPT_KILL() {
  NWNXPushString("SCRIPT_KILL");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SCRIPT_LOAD(
    string script
) {
  NWNXPushString("SCRIPT_LOAD");
  NWNXPushString(script);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SDIFF(
    string key
) {
  NWNXPushString("SDIFF");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SDIFFSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SDIFFSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SELECT(
    // Redis type: integer
    int index
) {
  NWNXPushString("SELECT");
  NWNXPushString(IntToString(index));
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_SETNX(
    string key,
    string value
) {
  NWNXPushString("SETNX");
  NWNXPushString(key);
  NWNXPushString(value);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_SHUTDOWN(
    // Redis type: enum
    string save_mode = ""
) {
  NWNXPushString("SHUTDOWN");
  if (save_mode != "") NWNXPushString(save_mode);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SINTER(
    string key
) {
  NWNXPushString("SINTER");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SINTERSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SINTERSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SISMEMBER(
    string key,
    string member
) {
  NWNXPushString("SISMEMBER");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SLAVEOF(
    string host,
    string port
) {
  NWNXPushString("SLAVEOF");
  NWNXPushString(host);
  NWNXPushString(port);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_REPLICAOF(
    string host,
    string port
) {
  NWNXPushString("REPLICAOF");
  NWNXPushString(host);
  NWNXPushString(port);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SLOWLOG(
    string subcommand,
    string argument = ""
) {
  NWNXPushString("SLOWLOG");
  NWNXPushString(subcommand);
  if (argument != "") NWNXPushString(argument);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SMEMBERS(
    string key
) {
  NWNXPushString("SMEMBERS");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_SREM(
    string key,
    string member
) {
  NWNXPushString("SREM");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_STRLEN(
    string key
) {
  NWNXPushString("STRLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SUNION(
    string key
) {
  NWNXPushString("SUNION");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_SUNIONSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNXPushString("SUNIONSTORE");
  NWNXPushString(destination);
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_SYNC() {
  NWNXPushString("SYNC");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_TIME() {
  NWNXPushString("TIME");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_TOUCH(
    string key
) {
  NWNXPushString("TOUCH");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_TTL(
    string key
) {
  NWNXPushString("TTL");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_TYPE(
    string key
) {
  NWNXPushString("TYPE");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_UNLINK(
    string key
) {
  NWNXPushString("UNLINK");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_UNWATCH() {
  NWNXPushString("UNWATCH");
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_WATCH(
    string key
) {
  NWNXPushString("WATCH");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_ZCARD(
    string key
) {
  NWNXPushString("ZCARD");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_ZLEXCOUNT(
    string key,
    string min,
    string max
) {
  NWNXPushString("ZLEXCOUNT");
  NWNXPushString(key);
  NWNXPushString(min);
  NWNXPushString(max);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_ZRANK(
    string key,
    string member
) {
  NWNXPushString("ZRANK");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_ZREM(
    string key,
    string member
) {
  NWNXPushString("ZREM");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_ZREMRANGEBYLEX(
    string key,
    string min,
    string max
) {
  NWNXPushString("ZREMRANGEBYLEX");
  NWNXPushString(key);
  NWNXPushString(min);
  NWNXPushString(max);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_ZREVRANK(
    string key,
    string member
) {
  NWNXPushString("ZREVRANK");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_ZSCORE(
    string key,
    string member
) {
  NWNXPushString("ZSCORE");
  NWNXPushString(key);
  NWNXPushString(member);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_XDEL(
    string key,
    string ID
) {
  NWNXPushString("XDEL");
  NWNXPushString(key);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_XLEN(
    string key
) {
  NWNXPushString("XLEN");
  NWNXPushString(key);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_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 NWNX_Redis_XACK(
    string key,
    string group,
    string ID
) {
  NWNXPushString("XACK");
  NWNXPushString(key);
  NWNXPushString(group);
  NWNXPushString(ID);
  NWNXCall("NWNX_Redis", "Deferred");
  return NWNXPopInt();
}
 
int NWNX_Redis_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 NWNX_Redis_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();
}