nwnx_redis.nss

Go to the documentation of this file.

#include "nwnx"
#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
) {
  NWNX_PushArgumentString("APPEND");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_AUTH(
    string password
) {
  NWNX_PushArgumentString("AUTH");
  NWNX_PushArgumentString(password);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BGREWRITEAOF() {
  NWNX_PushArgumentString("BGREWRITEAOF");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BGSAVE() {
  NWNX_PushArgumentString("BGSAVE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BITCOUNT(
    string key,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
) {
  NWNX_PushArgumentString("BITCOUNT");
  NWNX_PushArgumentString(key);
  if (start != 0) NWNX_PushArgumentString(IntToString(start));
  if (end != 0) NWNX_PushArgumentString(IntToString(end));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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
) {
  NWNX_PushArgumentString("BITFIELD");
  NWNX_PushArgumentString(key);
  if (get_type != "") NWNX_PushArgumentString(get_type);
  if (get_offset != 0) NWNX_PushArgumentString(IntToString(get_offset));
  if (set_type != "") NWNX_PushArgumentString(set_type);
  if (set_offset != 0) NWNX_PushArgumentString(IntToString(set_offset));
  if (set_value != 0) NWNX_PushArgumentString(IntToString(set_value));
  if (incrby_type != "") NWNX_PushArgumentString(incrby_type);
  if (incrby_offset != 0) NWNX_PushArgumentString(IntToString(incrby_offset));
  if (incrby_increment != 0) NWNX_PushArgumentString(IntToString(incrby_increment));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BITOP(
    string operation,
    // Redis type: key
    string destkey,
    string key
) {
  NWNX_PushArgumentString("BITOP");
  NWNX_PushArgumentString(operation);
  NWNX_PushArgumentString(destkey);
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BITPOS(
    string key,
    // Redis type: integer
    int bit,
    // Redis type: integer
    int start = 0,
    // Redis type: integer
    int end = 0
) {
  NWNX_PushArgumentString("BITPOS");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(bit));
  if (start != 0) NWNX_PushArgumentString(IntToString(start));
  if (end != 0) NWNX_PushArgumentString(IntToString(end));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BLPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("BLPOP");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BRPOP(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("BRPOP");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BRPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("BRPOPLPUSH");
  NWNX_PushArgumentString(source);
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BZPOPMIN(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("BZPOPMIN");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_BZPOPMAX(
    string key,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("BZPOPMAX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_ID() {
  NWNX_PushArgumentString("CLIENT_ID");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_KILL(
    string ip_port = "",
    // Redis type: integer
    int id_client_id = 0,
    string addr_ip_port = "",
    string skipme_yes_no = ""
) {
  NWNX_PushArgumentString("CLIENT_KILL");
  if (ip_port != "") NWNX_PushArgumentString(ip_port);
  if (id_client_id != 0) NWNX_PushArgumentString(IntToString(id_client_id));
  if (addr_ip_port != "") NWNX_PushArgumentString(addr_ip_port);
  if (skipme_yes_no != "") NWNX_PushArgumentString(skipme_yes_no);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_LIST() {
  NWNX_PushArgumentString("CLIENT_LIST");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_GETNAME() {
  NWNX_PushArgumentString("CLIENT_GETNAME");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_PAUSE(
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("CLIENT_PAUSE");
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_REPLY(
    // Redis type: enum
    string reply_mode
) {
  NWNX_PushArgumentString("CLIENT_REPLY");
  NWNX_PushArgumentString(reply_mode);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_SETNAME(
    string connection_name
) {
  NWNX_PushArgumentString("CLIENT_SETNAME");
  NWNX_PushArgumentString(connection_name);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLIENT_UNBLOCK(
    string client_id,
    // Redis type: enum
    string unblock_type = ""
) {
  NWNX_PushArgumentString("CLIENT_UNBLOCK");
  NWNX_PushArgumentString(client_id);
  if (unblock_type != "") NWNX_PushArgumentString(unblock_type);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_ADDSLOTS(
    // Redis type: integer
    int slot
) {
  NWNX_PushArgumentString("CLUSTER_ADDSLOTS");
  NWNX_PushArgumentString(IntToString(slot));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_COUNT_FAILURE_REPORTS(
    string node_id
) {
  NWNX_PushArgumentString("CLUSTER_COUNT_FAILURE_REPORTS");
  NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_COUNTKEYSINSLOT(
    // Redis type: integer
    int slot
) {
  NWNX_PushArgumentString("CLUSTER_COUNTKEYSINSLOT");
  NWNX_PushArgumentString(IntToString(slot));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_DELSLOTS(
    // Redis type: integer
    int slot
) {
  NWNX_PushArgumentString("CLUSTER_DELSLOTS");
  NWNX_PushArgumentString(IntToString(slot));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_FAILOVER(
    // Redis type: enum
    string options = ""
) {
  NWNX_PushArgumentString("CLUSTER_FAILOVER");
  if (options != "") NWNX_PushArgumentString(options);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_FORGET(
    string node_id
) {
  NWNX_PushArgumentString("CLUSTER_FORGET");
  NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_GETKEYSINSLOT(
    // Redis type: integer
    int slot,
    // Redis type: integer
    int count
) {
  NWNX_PushArgumentString("CLUSTER_GETKEYSINSLOT");
  NWNX_PushArgumentString(IntToString(slot));
  NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_INFO() {
  NWNX_PushArgumentString("CLUSTER_INFO");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_KEYSLOT(
    string key
) {
  NWNX_PushArgumentString("CLUSTER_KEYSLOT");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_MEET(
    string ip,
    // Redis type: integer
    int port
) {
  NWNX_PushArgumentString("CLUSTER_MEET");
  NWNX_PushArgumentString(ip);
  NWNX_PushArgumentString(IntToString(port));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_NODES() {
  NWNX_PushArgumentString("CLUSTER_NODES");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_REPLICATE(
    string node_id
) {
  NWNX_PushArgumentString("CLUSTER_REPLICATE");
  NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_RESET(
    // Redis type: enum
    string reset_type = ""
) {
  NWNX_PushArgumentString("CLUSTER_RESET");
  if (reset_type != "") NWNX_PushArgumentString(reset_type);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_SAVECONFIG() {
  NWNX_PushArgumentString("CLUSTER_SAVECONFIG");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_SET_CONFIG_EPOCH(
    // Redis type: integer
    int config_epoch
) {
  NWNX_PushArgumentString("CLUSTER_SET_CONFIG_EPOCH");
  NWNX_PushArgumentString(IntToString(config_epoch));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_SETSLOT(
    // Redis type: integer
    int slot,
    // Redis type: enum
    string subcommand,
    string node_id = ""
) {
  NWNX_PushArgumentString("CLUSTER_SETSLOT");
  NWNX_PushArgumentString(IntToString(slot));
  NWNX_PushArgumentString(subcommand);
  if (node_id != "") NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_SLAVES(
    string node_id
) {
  NWNX_PushArgumentString("CLUSTER_SLAVES");
  NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_REPLICAS(
    string node_id
) {
  NWNX_PushArgumentString("CLUSTER_REPLICAS");
  NWNX_PushArgumentString(node_id);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CLUSTER_SLOTS() {
  NWNX_PushArgumentString("CLUSTER_SLOTS");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_COMMAND() {
  NWNX_PushArgumentString("COMMAND");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_COMMAND_COUNT() {
  NWNX_PushArgumentString("COMMAND_COUNT");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_COMMAND_GETKEYS() {
  NWNX_PushArgumentString("COMMAND_GETKEYS");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_COMMAND_INFO(
    string command_name
) {
  NWNX_PushArgumentString("COMMAND_INFO");
  NWNX_PushArgumentString(command_name);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CONFIG_GET(
    string parameter
) {
  NWNX_PushArgumentString("CONFIG_GET");
  NWNX_PushArgumentString(parameter);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CONFIG_REWRITE() {
  NWNX_PushArgumentString("CONFIG_REWRITE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CONFIG_SET(
    string parameter,
    string value
) {
  NWNX_PushArgumentString("CONFIG_SET");
  NWNX_PushArgumentString(parameter);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_CONFIG_RESETSTAT() {
  NWNX_PushArgumentString("CONFIG_RESETSTAT");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DBSIZE() {
  NWNX_PushArgumentString("DBSIZE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DEBUG_OBJECT(
    string key
) {
  NWNX_PushArgumentString("DEBUG_OBJECT");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DEBUG_SEGFAULT() {
  NWNX_PushArgumentString("DEBUG_SEGFAULT");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DECR(
    string key
) {
  NWNX_PushArgumentString("DECR");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DECRBY(
    string key,
    // Redis type: integer
    int decrement
) {
  NWNX_PushArgumentString("DECRBY");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(decrement));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DEL(
    string key
) {
  NWNX_PushArgumentString("DEL");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DISCARD() {
  NWNX_PushArgumentString("DISCARD");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_DUMP(
    string key
) {
  NWNX_PushArgumentString("DUMP");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ECHO(
    string message
) {
  NWNX_PushArgumentString("ECHO");
  NWNX_PushArgumentString(message);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EVAL(
    string script,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
) {
  NWNX_PushArgumentString("EVAL");
  NWNX_PushArgumentString(script);
  NWNX_PushArgumentString(IntToString(numkeys));
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(arg);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EVALSHA(
    string sha1,
    // Redis type: integer
    int numkeys,
    string key,
    string arg
) {
  NWNX_PushArgumentString("EVALSHA");
  NWNX_PushArgumentString(sha1);
  NWNX_PushArgumentString(IntToString(numkeys));
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(arg);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EXEC() {
  NWNX_PushArgumentString("EXEC");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EXISTS(
    string key
) {
  NWNX_PushArgumentString("EXISTS");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EXPIRE(
    string key,
    // Redis type: integer
    int seconds
) {
  NWNX_PushArgumentString("EXPIRE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(seconds));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_EXPIREAT(
    string key,
    // Redis type: posix time
    string timestamp
) {
  NWNX_PushArgumentString("EXPIREAT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(timestamp);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_FLUSHALL(
    // Redis type: enum
    string async = ""
) {
  NWNX_PushArgumentString("FLUSHALL");
  if (async != "") NWNX_PushArgumentString(async);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_FLUSHDB(
    // Redis type: enum
    string async = ""
) {
  NWNX_PushArgumentString("FLUSHDB");
  if (async != "") NWNX_PushArgumentString(async);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GEOADD(
    string key,
    // Redis type: double
    float longitude,
    // Redis type: double
    float latitude,
    string member
) {
  NWNX_PushArgumentString("GEOADD");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(longitude, 0));
  NWNX_PushArgumentString(FloatToString(latitude, 0));
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GEOHASH(
    string key,
    string member
) {
  NWNX_PushArgumentString("GEOHASH");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GEOPOS(
    string key,
    string member
) {
  NWNX_PushArgumentString("GEOPOS");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GEODIST(
    string key,
    string member1,
    string member2,
    string unit = ""
) {
  NWNX_PushArgumentString("GEODIST");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member1);
  NWNX_PushArgumentString(member2);
  if (unit != "") NWNX_PushArgumentString(unit);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("GEORADIUS");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(longitude, 0));
  NWNX_PushArgumentString(FloatToString(latitude, 0));
  NWNX_PushArgumentString(FloatToString(radius, 0));
  NWNX_PushArgumentString(unit);
  if (withcoord != "") NWNX_PushArgumentString(withcoord);
  if (withdist != "") NWNX_PushArgumentString(withdist);
  if (withhash != "") NWNX_PushArgumentString(withhash);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  if (order != "") NWNX_PushArgumentString(order);
  if (store_key != "") NWNX_PushArgumentString(store_key);
  if (storedist_key != "") NWNX_PushArgumentString(storedist_key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("GEORADIUSBYMEMBER");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_PushArgumentString(FloatToString(radius, 0));
  NWNX_PushArgumentString(unit);
  if (withcoord != "") NWNX_PushArgumentString(withcoord);
  if (withdist != "") NWNX_PushArgumentString(withdist);
  if (withhash != "") NWNX_PushArgumentString(withhash);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  if (order != "") NWNX_PushArgumentString(order);
  if (store_key != "") NWNX_PushArgumentString(store_key);
  if (storedist_key != "") NWNX_PushArgumentString(storedist_key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GET(
    string key
) {
  NWNX_PushArgumentString("GET");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GETBIT(
    string key,
    // Redis type: integer
    int offset
) {
  NWNX_PushArgumentString("GETBIT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(offset));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GETRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int end
) {
  NWNX_PushArgumentString("GETRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(end));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_GETSET(
    string key,
    string value
) {
  NWNX_PushArgumentString("GETSET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HDEL(
    string key,
    string field
) {
  NWNX_PushArgumentString("HDEL");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HEXISTS(
    string key,
    string field
) {
  NWNX_PushArgumentString("HEXISTS");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HGET(
    string key,
    string field
) {
  NWNX_PushArgumentString("HGET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HGETALL(
    string key
) {
  NWNX_PushArgumentString("HGETALL");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HINCRBY(
    string key,
    string field,
    // Redis type: integer
    int increment
) {
  NWNX_PushArgumentString("HINCRBY");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(IntToString(increment));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HINCRBYFLOAT(
    string key,
    string field,
    // Redis type: double
    float increment
) {
  NWNX_PushArgumentString("HINCRBYFLOAT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(FloatToString(increment, 0));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HKEYS(
    string key
) {
  NWNX_PushArgumentString("HKEYS");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HLEN(
    string key
) {
  NWNX_PushArgumentString("HLEN");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HMGET(
    string key,
    string field
) {
  NWNX_PushArgumentString("HMGET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HMSET(
    string key,
    string field,
    string value
) {
  NWNX_PushArgumentString("HMSET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HSET(
    string key,
    string field,
    string value
) {
  NWNX_PushArgumentString("HSET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HSETNX(
    string key,
    string field,
    string value
) {
  NWNX_PushArgumentString("HSETNX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HSTRLEN(
    string key,
    string field
) {
  NWNX_PushArgumentString("HSTRLEN");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(field);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HVALS(
    string key
) {
  NWNX_PushArgumentString("HVALS");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_INCR(
    string key
) {
  NWNX_PushArgumentString("INCR");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_INCRBY(
    string key,
    // Redis type: integer
    int increment
) {
  NWNX_PushArgumentString("INCRBY");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(increment));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_INCRBYFLOAT(
    string key,
    // Redis type: double
    float increment
) {
  NWNX_PushArgumentString("INCRBYFLOAT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(increment, 0));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_INFO(
    string section = ""
) {
  NWNX_PushArgumentString("INFO");
  if (section != "") NWNX_PushArgumentString(section);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_KEYS(
    string pattern
) {
  NWNX_PushArgumentString("KEYS");
  NWNX_PushArgumentString(pattern);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LASTSAVE() {
  NWNX_PushArgumentString("LASTSAVE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LINDEX(
    string key,
    // Redis type: integer
    int index
) {
  NWNX_PushArgumentString("LINDEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(index));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LINSERT(
    string key,
    // Redis type: enum
    string where,
    string pivot,
    string value
) {
  NWNX_PushArgumentString("LINSERT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(where);
  NWNX_PushArgumentString(pivot);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LLEN(
    string key
) {
  NWNX_PushArgumentString("LLEN");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LPOP(
    string key
) {
  NWNX_PushArgumentString("LPOP");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LPUSH(
    string key,
    string value
) {
  NWNX_PushArgumentString("LPUSH");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LPUSHX(
    string key,
    string value
) {
  NWNX_PushArgumentString("LPUSHX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNX_PushArgumentString("LRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(stop));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LREM(
    string key,
    // Redis type: integer
    int count,
    string value
) {
  NWNX_PushArgumentString("LREM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(count));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LSET(
    string key,
    // Redis type: integer
    int index,
    string value
) {
  NWNX_PushArgumentString("LSET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(index));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_LTRIM(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNX_PushArgumentString("LTRIM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(stop));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_DOCTOR() {
  NWNX_PushArgumentString("MEMORY_DOCTOR");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_HELP() {
  NWNX_PushArgumentString("MEMORY_HELP");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_MALLOC_STATS() {
  NWNX_PushArgumentString("MEMORY_MALLOC_STATS");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_PURGE() {
  NWNX_PushArgumentString("MEMORY_PURGE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_STATS() {
  NWNX_PushArgumentString("MEMORY_STATS");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MEMORY_USAGE(
    string key,
    // Redis type: integer
    int samples_count = 0
) {
  NWNX_PushArgumentString("MEMORY_USAGE");
  NWNX_PushArgumentString(key);
  if (samples_count != 0) NWNX_PushArgumentString(IntToString(samples_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MGET(
    string key
) {
  NWNX_PushArgumentString("MGET");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("MIGRATE");
  NWNX_PushArgumentString(host);
  NWNX_PushArgumentString(port);
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(destination_db));
  NWNX_PushArgumentString(IntToString(timeout));
  if (copy != "") NWNX_PushArgumentString(copy);
  if (replace != "") NWNX_PushArgumentString(replace);
  if (auth_password != "") NWNX_PushArgumentString(auth_password);
  if (keys_key != "") NWNX_PushArgumentString(keys_key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MONITOR() {
  NWNX_PushArgumentString("MONITOR");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MOVE(
    string key,
    // Redis type: integer
    int db
) {
  NWNX_PushArgumentString("MOVE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(db));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MSET(
    string key,
    string value
) {
  NWNX_PushArgumentString("MSET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MSETNX(
    string key,
    string value
) {
  NWNX_PushArgumentString("MSETNX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_MULTI() {
  NWNX_PushArgumentString("MULTI");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_OBJECT(
    string subcommand,
    string arguments = ""
) {
  NWNX_PushArgumentString("OBJECT");
  NWNX_PushArgumentString(subcommand);
  if (arguments != "") NWNX_PushArgumentString(arguments);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PERSIST(
    string key
) {
  NWNX_PushArgumentString("PERSIST");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PEXPIRE(
    string key,
    // Redis type: integer
    int milliseconds
) {
  NWNX_PushArgumentString("PEXPIRE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(milliseconds));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PEXPIREAT(
    string key,
    // Redis type: posix time
    string milliseconds_timestamp
) {
  NWNX_PushArgumentString("PEXPIREAT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(milliseconds_timestamp);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PFADD(
    string key,
    string element
) {
  NWNX_PushArgumentString("PFADD");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(element);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PFCOUNT(
    string key
) {
  NWNX_PushArgumentString("PFCOUNT");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PFMERGE(
    // Redis type: key
    string destkey,
    // Redis type: key
    string sourcekey
) {
  NWNX_PushArgumentString("PFMERGE");
  NWNX_PushArgumentString(destkey);
  NWNX_PushArgumentString(sourcekey);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PING(
    string message = ""
) {
  NWNX_PushArgumentString("PING");
  if (message != "") NWNX_PushArgumentString(message);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PSETEX(
    string key,
    // Redis type: integer
    int milliseconds,
    string value
) {
  NWNX_PushArgumentString("PSETEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(milliseconds));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PUBSUB(
    string subcommand,
    string argument = ""
) {
  NWNX_PushArgumentString("PUBSUB");
  NWNX_PushArgumentString(subcommand);
  if (argument != "") NWNX_PushArgumentString(argument);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PTTL(
    string key
) {
  NWNX_PushArgumentString("PTTL");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_PUBLISH(
    string channel,
    string message
) {
  NWNX_PushArgumentString("PUBLISH");
  NWNX_PushArgumentString(channel);
  NWNX_PushArgumentString(message);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_QUIT() {
  NWNX_PushArgumentString("QUIT");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RANDOMKEY() {
  NWNX_PushArgumentString("RANDOMKEY");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_READONLY() {
  NWNX_PushArgumentString("READONLY");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_READWRITE() {
  NWNX_PushArgumentString("READWRITE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RENAME(
    string key,
    // Redis type: key
    string newkey
) {
  NWNX_PushArgumentString("RENAME");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(newkey);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RENAMENX(
    string key,
    // Redis type: key
    string newkey
) {
  NWNX_PushArgumentString("RENAMENX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(newkey);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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
) {
  NWNX_PushArgumentString("RESTORE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(ttl));
  NWNX_PushArgumentString(serialized_value);
  if (replace != "") NWNX_PushArgumentString(replace);
  if (absttl != "") NWNX_PushArgumentString(absttl);
  if (idletime_seconds != 0) NWNX_PushArgumentString(IntToString(idletime_seconds));
  if (freq_frequency != 0) NWNX_PushArgumentString(IntToString(freq_frequency));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ROLE() {
  NWNX_PushArgumentString("ROLE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RPOP(
    string key
) {
  NWNX_PushArgumentString("RPOP");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RPOPLPUSH(
    // Redis type: key
    string source,
    // Redis type: key
    string destination
) {
  NWNX_PushArgumentString("RPOPLPUSH");
  NWNX_PushArgumentString(source);
  NWNX_PushArgumentString(destination);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RPUSH(
    string key,
    string value
) {
  NWNX_PushArgumentString("RPUSH");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_RPUSHX(
    string key,
    string value
) {
  NWNX_PushArgumentString("RPUSHX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SADD(
    string key,
    string member
) {
  NWNX_PushArgumentString("SADD");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SAVE() {
  NWNX_PushArgumentString("SAVE");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCARD(
    string key
) {
  NWNX_PushArgumentString("SCARD");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCRIPT_DEBUG(
    // Redis type: enum
    string mode
) {
  NWNX_PushArgumentString("SCRIPT_DEBUG");
  NWNX_PushArgumentString(mode);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCRIPT_EXISTS(
    string sha1
) {
  NWNX_PushArgumentString("SCRIPT_EXISTS");
  NWNX_PushArgumentString(sha1);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCRIPT_FLUSH() {
  NWNX_PushArgumentString("SCRIPT_FLUSH");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCRIPT_KILL() {
  NWNX_PushArgumentString("SCRIPT_KILL");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SCRIPT_LOAD(
    string script
) {
  NWNX_PushArgumentString("SCRIPT_LOAD");
  NWNX_PushArgumentString(script);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SDIFF(
    string key
) {
  NWNX_PushArgumentString("SDIFF");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SDIFFSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNX_PushArgumentString("SDIFFSTORE");
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SELECT(
    // Redis type: integer
    int index
) {
  NWNX_PushArgumentString("SELECT");
  NWNX_PushArgumentString(IntToString(index));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SET(
    string key,
    string value,
    // Redis type: enum
    string condition = ""
) {
  NWNX_PushArgumentString("SET");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  if (condition != "") NWNX_PushArgumentString(condition);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SETBIT(
    string key,
    // Redis type: integer
    int offset,
    string value
) {
  NWNX_PushArgumentString("SETBIT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(offset));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SETEX(
    string key,
    // Redis type: integer
    int seconds,
    string value
) {
  NWNX_PushArgumentString("SETEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(seconds));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SETNX(
    string key,
    string value
) {
  NWNX_PushArgumentString("SETNX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SETRANGE(
    string key,
    // Redis type: integer
    int offset,
    string value
) {
  NWNX_PushArgumentString("SETRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(offset));
  NWNX_PushArgumentString(value);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SHUTDOWN(
    // Redis type: enum
    string save_mode = ""
) {
  NWNX_PushArgumentString("SHUTDOWN");
  if (save_mode != "") NWNX_PushArgumentString(save_mode);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SINTER(
    string key
) {
  NWNX_PushArgumentString("SINTER");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SINTERSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNX_PushArgumentString("SINTERSTORE");
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SISMEMBER(
    string key,
    string member
) {
  NWNX_PushArgumentString("SISMEMBER");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SLAVEOF(
    string host,
    string port
) {
  NWNX_PushArgumentString("SLAVEOF");
  NWNX_PushArgumentString(host);
  NWNX_PushArgumentString(port);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_REPLICAOF(
    string host,
    string port
) {
  NWNX_PushArgumentString("REPLICAOF");
  NWNX_PushArgumentString(host);
  NWNX_PushArgumentString(port);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SLOWLOG(
    string subcommand,
    string argument = ""
) {
  NWNX_PushArgumentString("SLOWLOG");
  NWNX_PushArgumentString(subcommand);
  if (argument != "") NWNX_PushArgumentString(argument);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SMEMBERS(
    string key
) {
  NWNX_PushArgumentString("SMEMBERS");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SMOVE(
    // Redis type: key
    string source,
    // Redis type: key
    string destination,
    string member
) {
  NWNX_PushArgumentString("SMOVE");
  NWNX_PushArgumentString(source);
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("SORT");
  NWNX_PushArgumentString(key);
  if (by_pattern != "") NWNX_PushArgumentString(by_pattern);
  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
  if (get_pattern != "") NWNX_PushArgumentString(get_pattern);
  if (order != "") NWNX_PushArgumentString(order);
  if (sorting != "") NWNX_PushArgumentString(sorting);
  if (store_destination != "") NWNX_PushArgumentString(store_destination);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SPOP(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNX_PushArgumentString("SPOP");
  NWNX_PushArgumentString(key);
  if (count != 0) NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SRANDMEMBER(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNX_PushArgumentString("SRANDMEMBER");
  NWNX_PushArgumentString(key);
  if (count != 0) NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SREM(
    string key,
    string member
) {
  NWNX_PushArgumentString("SREM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_STRLEN(
    string key
) {
  NWNX_PushArgumentString("STRLEN");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SUNION(
    string key
) {
  NWNX_PushArgumentString("SUNION");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SUNIONSTORE(
    // Redis type: key
    string destination,
    string key
) {
  NWNX_PushArgumentString("SUNIONSTORE");
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SWAPDB(
    // Redis type: integer
    int index,
    // Redis type: integer
    int index_1
) {
  NWNX_PushArgumentString("SWAPDB");
  NWNX_PushArgumentString(IntToString(index));
  NWNX_PushArgumentString(IntToString(index_1));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SYNC() {
  NWNX_PushArgumentString("SYNC");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_TIME() {
  NWNX_PushArgumentString("TIME");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_TOUCH(
    string key
) {
  NWNX_PushArgumentString("TOUCH");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_TTL(
    string key
) {
  NWNX_PushArgumentString("TTL");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_TYPE(
    string key
) {
  NWNX_PushArgumentString("TYPE");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_UNLINK(
    string key
) {
  NWNX_PushArgumentString("UNLINK");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_UNWATCH() {
  NWNX_PushArgumentString("UNWATCH");
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_WAIT(
    // Redis type: integer
    int numreplicas,
    // Redis type: integer
    int timeout
) {
  NWNX_PushArgumentString("WAIT");
  NWNX_PushArgumentString(IntToString(numreplicas));
  NWNX_PushArgumentString(IntToString(timeout));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_WATCH(
    string key
) {
  NWNX_PushArgumentString("WATCH");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("ZADD");
  NWNX_PushArgumentString(key);
  if (condition != "") NWNX_PushArgumentString(condition);
  if (change != "") NWNX_PushArgumentString(change);
  if (increment != "") NWNX_PushArgumentString(increment);
  NWNX_PushArgumentString(FloatToString(score, 0));
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZCARD(
    string key
) {
  NWNX_PushArgumentString("ZCARD");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZCOUNT(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
) {
  NWNX_PushArgumentString("ZCOUNT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(min, 0));
  NWNX_PushArgumentString(FloatToString(max, 0));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZINCRBY(
    string key,
    // Redis type: integer
    int increment,
    string member
) {
  NWNX_PushArgumentString("ZINCRBY");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(increment));
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("ZINTERSTORE");
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(IntToString(numkeys));
  NWNX_PushArgumentString(key);
  if (weights_weight != 0) NWNX_PushArgumentString(IntToString(weights_weight));
  if (aggregate_aggregate != "") NWNX_PushArgumentString(aggregate_aggregate);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZLEXCOUNT(
    string key,
    string min,
    string max
) {
  NWNX_PushArgumentString("ZLEXCOUNT");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(min);
  NWNX_PushArgumentString(max);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZPOPMAX(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNX_PushArgumentString("ZPOPMAX");
  NWNX_PushArgumentString(key);
  if (count != 0) NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZPOPMIN(
    string key,
    // Redis type: integer
    int count = 0
) {
  NWNX_PushArgumentString("ZPOPMIN");
  NWNX_PushArgumentString(key);
  if (count != 0) NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
) {
  NWNX_PushArgumentString("ZRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(stop));
  if (withscores != "") NWNX_PushArgumentString(withscores);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZRANGEBYLEX(
    string key,
    string min,
    string max,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNX_PushArgumentString("ZRANGEBYLEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(min);
  NWNX_PushArgumentString(max);
  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREVRANGEBYLEX(
    string key,
    string max,
    string min,
    // Redis type: integer
    int limit_offset = 0,
    // Redis type: integer
    int limit_count = 0
) {
  NWNX_PushArgumentString("ZREVRANGEBYLEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(max);
  NWNX_PushArgumentString(min);
  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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
) {
  NWNX_PushArgumentString("ZRANGEBYSCORE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(min, 0));
  NWNX_PushArgumentString(FloatToString(max, 0));
  if (withscores != "") NWNX_PushArgumentString(withscores);
  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZRANK(
    string key,
    string member
) {
  NWNX_PushArgumentString("ZRANK");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREM(
    string key,
    string member
) {
  NWNX_PushArgumentString("ZREM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREMRANGEBYLEX(
    string key,
    string min,
    string max
) {
  NWNX_PushArgumentString("ZREMRANGEBYLEX");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(min);
  NWNX_PushArgumentString(max);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREMRANGEBYRANK(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop
) {
  NWNX_PushArgumentString("ZREMRANGEBYRANK");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(stop));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREMRANGEBYSCORE(
    string key,
    // Redis type: double
    float min,
    // Redis type: double
    float max
) {
  NWNX_PushArgumentString("ZREMRANGEBYSCORE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(min, 0));
  NWNX_PushArgumentString(FloatToString(max, 0));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREVRANGE(
    string key,
    // Redis type: integer
    int start,
    // Redis type: integer
    int stop,
    // Redis type: enum
    string withscores = ""
) {
  NWNX_PushArgumentString("ZREVRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(start));
  NWNX_PushArgumentString(IntToString(stop));
  if (withscores != "") NWNX_PushArgumentString(withscores);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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
) {
  NWNX_PushArgumentString("ZREVRANGEBYSCORE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(FloatToString(max, 0));
  NWNX_PushArgumentString(FloatToString(min, 0));
  if (withscores != "") NWNX_PushArgumentString(withscores);
  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZREVRANK(
    string key,
    string member
) {
  NWNX_PushArgumentString("ZREVRANK");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZSCORE(
    string key,
    string member
) {
  NWNX_PushArgumentString("ZSCORE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(member);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("ZUNIONSTORE");
  NWNX_PushArgumentString(destination);
  NWNX_PushArgumentString(IntToString(numkeys));
  NWNX_PushArgumentString(key);
  if (weights_weight != 0) NWNX_PushArgumentString(IntToString(weights_weight));
  if (aggregate_aggregate != "") NWNX_PushArgumentString(aggregate_aggregate);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("SCAN");
  NWNX_PushArgumentString(IntToString(cursor));
  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  if (type_type != "") NWNX_PushArgumentString(type_type);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_SSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNX_PushArgumentString("SSCAN");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(cursor));
  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_HSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNX_PushArgumentString("HSCAN");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(cursor));
  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_ZSCAN(
    string key,
    // Redis type: integer
    int cursor,
    // Redis type: pattern
    string match_pattern = "",
    // Redis type: integer
    int count_count = 0
) {
  NWNX_PushArgumentString("ZSCAN");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(IntToString(cursor));
  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("XINFO");
  if (consumers_key != "") NWNX_PushArgumentString(consumers_key);
  if (consumers_groupname != "") NWNX_PushArgumentString(consumers_groupname);
  if (groups_key != "") NWNX_PushArgumentString(groups_key);
  if (stream_key != "") NWNX_PushArgumentString(stream_key);
  if (help != "") NWNX_PushArgumentString(help);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XADD(
    string key,
    string ID,
    // Redis type: value
    string field,
    string str
) {
  NWNX_PushArgumentString("XADD");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(ID);
  NWNX_PushArgumentString(field);
  NWNX_PushArgumentString(str);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XTRIM(
    string key,
    // Redis type: enum
    string strategy,
    // Redis type: enum
    string approx = "",
    // Redis type: integer
    int count = 0
) {
  NWNX_PushArgumentString("XTRIM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(strategy);
  if (approx != "") NWNX_PushArgumentString(approx);
  NWNX_PushArgumentString(IntToString(count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XDEL(
    string key,
    string ID
) {
  NWNX_PushArgumentString("XDEL");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(ID);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XRANGE(
    string key,
    string start,
    string end,
    // Redis type: integer
    int count_count = 0
) {
  NWNX_PushArgumentString("XRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(start);
  NWNX_PushArgumentString(end);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XREVRANGE(
    string key,
    string end,
    string start,
    // Redis type: integer
    int count_count = 0
) {
  NWNX_PushArgumentString("XREVRANGE");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(end);
  NWNX_PushArgumentString(start);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XLEN(
    string key
) {
  NWNX_PushArgumentString("XLEN");
  NWNX_PushArgumentString(key);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("XREAD");
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  if (block_milliseconds != 0) NWNX_PushArgumentString(IntToString(block_milliseconds));
  NWNX_PushArgumentString(streams);
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(ID);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("XGROUP");
  if (create_key != "") NWNX_PushArgumentString(create_key);
  if (create_groupname != "") NWNX_PushArgumentString(create_groupname);
  if (create_id_or__ != "") NWNX_PushArgumentString(create_id_or__);
  if (setid_key != "") NWNX_PushArgumentString(setid_key);
  if (setid_groupname != "") NWNX_PushArgumentString(setid_groupname);
  if (setid_id_or__ != "") NWNX_PushArgumentString(setid_id_or__);
  if (destroy_key != "") NWNX_PushArgumentString(destroy_key);
  if (destroy_groupname != "") NWNX_PushArgumentString(destroy_groupname);
  if (delconsumer_key != "") NWNX_PushArgumentString(delconsumer_key);
  if (delconsumer_groupname != "") NWNX_PushArgumentString(delconsumer_groupname);
  if (delconsumer_consumername != "") NWNX_PushArgumentString(delconsumer_consumername);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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 = ""
) {
  NWNX_PushArgumentString("XREADGROUP");
  NWNX_PushArgumentString(group_group);
  NWNX_PushArgumentString(group_consumer);
  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
  if (block_milliseconds != 0) NWNX_PushArgumentString(IntToString(block_milliseconds));
  if (noack != "") NWNX_PushArgumentString(noack);
  NWNX_PushArgumentString(streams);
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(ID);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XACK(
    string key,
    string group,
    string ID
) {
  NWNX_PushArgumentString("XACK");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(group);
  NWNX_PushArgumentString(ID);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
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
) {
  NWNX_PushArgumentString("XCLAIM");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(group);
  NWNX_PushArgumentString(consumer);
  NWNX_PushArgumentString(min_idle_time);
  NWNX_PushArgumentString(ID);
  if (idle_ms != 0) NWNX_PushArgumentString(IntToString(idle_ms));
  if (time_ms_unix_time != 0) NWNX_PushArgumentString(IntToString(time_ms_unix_time));
  if (retrycount_count != 0) NWNX_PushArgumentString(IntToString(retrycount_count));
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}
 
int NWNX_Redis_XPENDING(
    string key,
    string group,
    string start = "",
    string end = "",
    // Redis type: integer
    int count = 0,
    string consumer = ""
) {
  NWNX_PushArgumentString("XPENDING");
  NWNX_PushArgumentString(key);
  NWNX_PushArgumentString(group);
  if (start != "") NWNX_PushArgumentString(start);
  if (end != "") NWNX_PushArgumentString(end);
  if (count != 0) NWNX_PushArgumentString(IntToString(count));
  if (consumer != "") NWNX_PushArgumentString(consumer);
  NWNX_CallFunction("NWNX_Redis", "Deferred");
  return NWNX_GetReturnValueInt();
}