ES_PRC8/_module/nss/nwnx_redis.nss

/// @ingroup redis
/// @brief Autogenerated redis commands for NWNX usage. Autogenerated on: 2019-10-01 20:51:53 -0400
/// @{
/// @file nwnx_redis.nss
/// @name Redis Commands
#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.
/**
 * APPEND
 *
 * Append a value to a key
 *
 * Time complexity: O(1). The amortized time complexity is O(1) assuming the appended value is
 * small and the already present value is of any size, since the dynamic string
 * library used by Redis will double the free space available on every
 * reallocation.
 * Annotated return value: integer
 */
int NWNX_Redis_APPEND(
	string key,
	string value
);

/**
 * AUTH
 *
 * Authenticate to the server
 * Annotated return value: simple-string
 */
int NWNX_Redis_AUTH(
	string password
);

/**
 * BGREWRITEAOF
 *
 * Asynchronously rewrite the append-only file
 * Annotated return value: simple-string
 */
int NWNX_Redis_BGREWRITEAOF();

/**
 * BGSAVE
 *
 * Asynchronously save the dataset to disk
 * Annotated return value: simple-string
 */
int NWNX_Redis_BGSAVE();

/**
 * BITCOUNT
 *
 * Count set bits in a string
 *
 * Time complexity: O(N)
 * Annotated return value: integer
 */
int NWNX_Redis_BITCOUNT(
	string key,
	// Redis type: integer
	int start = 0,
	// Redis type: integer
	int end = 0
);

/**
 * BITFIELD
 *
 * Perform arbitrary bitfield integer operations on strings
 *
 * Time complexity: O(1) for each subcommand specified
 * Annotated return value:
 */
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
);

/**
 * BITOP
 *
 * Perform bitwise operations between strings
 *
 * Time complexity: O(N)
 * Annotated return value: integer
 */
int NWNX_Redis_BITOP(
	string operation,
	// Redis type: key
	string destkey,
	string key
);

/**
 * BITPOS
 *
 * Find first bit set or clear in a string
 *
 * Time complexity: O(N)
 * Annotated return value: integer
 */
int NWNX_Redis_BITPOS(
	string key,
	// Redis type: integer
	int bit,
	// Redis type: integer
	int start = 0,
	// Redis type: integer
	int end = 0
);

/**
 * BLPOP
 *
 * Remove and get the first element in a list, or block until one is available
 *
 * Time complexity: O(1)
 * Annotated return value: array
 */
int NWNX_Redis_BLPOP(
	string key,
	// Redis type: integer
	int timeout
);

/**
 * BRPOP
 *
 * Remove and get the last element in a list, or block until one is available
 *
 * Time complexity: O(1)
 * Annotated return value: array
 */
int NWNX_Redis_BRPOP(
	string key,
	// Redis type: integer
	int timeout
);

/**
 * BRPOPLPUSH
 *
 * Pop a value from a list, push it to another list and return it; or block until one is available
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_BRPOPLPUSH(
	// Redis type: key
	string source,
	// Redis type: key
	string destination,
	// Redis type: integer
	int timeout
);

/**
 * BZPOPMIN
 *
 * Remove and return the member with the lowest score from one or more sorted sets, or block until one is available
 *
 * Time complexity: O(log(N)) with N being the number of elements in the sorted set.
 * Annotated return value: array
 */
int NWNX_Redis_BZPOPMIN(
	string key,
	// Redis type: integer
	int timeout
);

/**
 * BZPOPMAX
 *
 * Remove and return the member with the highest score from one or more sorted sets, or block until one is available
 *
 * Time complexity: O(log(N)) with N being the number of elements in the sorted set.
 * Annotated return value: array
 */
int NWNX_Redis_BZPOPMAX(
	string key,
	// Redis type: integer
	int timeout
);

/**
 * CLIENT_ID
 *
 * Returns the client ID for the current connection
 *
 * Time complexity: O(1)
 * Annotated return value:
 */
int NWNX_Redis_CLIENT_ID();

/**
 * CLIENT_KILL
 *
 * Kill the connection of a client
 *
 * Time complexity: O(N) where N is the number of client connections
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLIENT_KILL(
	string ip_port = "",
	// Redis type: integer
	int id_client_id = 0,
	string addr_ip_port = "",
	string skipme_yes_no = ""
);

/**
 * CLIENT_LIST
 *
 * Get the list of client connections
 *
 * Time complexity: O(N) where N is the number of client connections
 * Annotated return value: bulk-string
 */
int NWNX_Redis_CLIENT_LIST();

/**
 * CLIENT_GETNAME
 *
 * Get the current connection name
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_CLIENT_GETNAME();

/**
 * CLIENT_PAUSE
 *
 * Stop processing commands from clients for some time
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLIENT_PAUSE(
	// Redis type: integer
	int timeout
);

/**
 * CLIENT_REPLY
 *
 * Instruct the server whether to reply to commands
 *
 * Time complexity: O(1)

 * - Valid values for reply_mode: "ON", "OFF", "SKIP"
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLIENT_REPLY(
	// Redis type: enum
	string reply_mode
);

/**
 * CLIENT_SETNAME
 *
 * Set the current connection name
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLIENT_SETNAME(
	string connection_name
);

/**
 * CLIENT_UNBLOCK
 *
 * Unblock a client blocked in a blocking command from a different connection
 *
 * Time complexity: O(log N) where N is the number of client connections

 * - Valid values for unblock_type: "TIMEOUT", "ERROR"
 * Annotated return value:
 */
int NWNX_Redis_CLIENT_UNBLOCK(
	string client_id,
	// Redis type: enum
	string unblock_type = ""
);

/**
 * CLUSTER_ADDSLOTS
 *
 * Assign new hash slots to receiving node
 *
 * Time complexity: O(N) where N is the total number of hash slot arguments
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_ADDSLOTS(
	// Redis type: integer
	int slot
);

/**
 * CLUSTER_COUNT_FAILURE_REPORTS
 *
 * Return the number of failure reports active for a given node
 *
 * Time complexity: O(N) where N is the number of failure reports
 * Annotated return value: integer
 */
int NWNX_Redis_CLUSTER_COUNT_FAILURE_REPORTS(
	string node_id
);

/**
 * CLUSTER_COUNTKEYSINSLOT
 *
 * Return the number of local keys in the specified hash slot
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_CLUSTER_COUNTKEYSINSLOT(
	// Redis type: integer
	int slot
);

/**
 * CLUSTER_DELSLOTS
 *
 * Set hash slots as unbound in receiving node
 *
 * Time complexity: O(N) where N is the total number of hash slot arguments
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_DELSLOTS(
	// Redis type: integer
	int slot
);

/**
 * CLUSTER_FAILOVER
 *
 * Forces a replica to perform a manual failover of its master.
 *
 * Time complexity: O(1)

 * - Valid values for options: "FORCE", "TAKEOVER"
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_FAILOVER(
	// Redis type: enum
	string options = ""
);

/**
 * CLUSTER_FORGET
 *
 * Remove a node from the nodes table
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_FORGET(
	string node_id
);

/**
 * CLUSTER_GETKEYSINSLOT
 *
 * Return local key names in the specified hash slot
 *
 * Time complexity: O(log(N)) where N is the number of requested keys
 * Annotated return value: array
 */
int NWNX_Redis_CLUSTER_GETKEYSINSLOT(
	// Redis type: integer
	int slot,
	// Redis type: integer
	int count
);

/**
 * CLUSTER_INFO
 *
 * Provides info about Redis Cluster node state
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_CLUSTER_INFO();

/**
 * CLUSTER_KEYSLOT
 *
 * Returns the hash slot of the specified key
 *
 * Time complexity: O(N) where N is the number of bytes in the key
 * Annotated return value: integer
 */
int NWNX_Redis_CLUSTER_KEYSLOT(
	string key
);

/**
 * CLUSTER_MEET
 *
 * Force a node cluster to handshake with another node
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_MEET(
	string ip,
	// Redis type: integer
	int port
);

/**
 * CLUSTER_NODES
 *
 * Get Cluster config for the node
 *
 * Time complexity: O(N) where N is the total number of Cluster nodes
 * Annotated return value: bulk-string
 */
int NWNX_Redis_CLUSTER_NODES();

/**
 * CLUSTER_REPLICATE
 *
 * Reconfigure a node as a replica of the specified master node
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_REPLICATE(
	string node_id
);

/**
 * CLUSTER_RESET
 *
 * Reset a Redis Cluster node
 *
 * Time complexity: O(N) where N is the number of known nodes. The command may execute a
 * FLUSHALL as a side effect.

 * - Valid values for reset_type: "HARD", "SOFT"
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_RESET(
	// Redis type: enum
	string reset_type = ""
);

/**
 * CLUSTER_SAVECONFIG
 *
 * Forces the node to save cluster state on disk
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_SAVECONFIG();

/**
 * CLUSTER_SET_CONFIG_EPOCH
 *
 * Set the configuration epoch in a new node
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_SET_CONFIG_EPOCH(
	// Redis type: integer
	int config_epoch
);

/**
 * CLUSTER_SETSLOT
 *
 * Bind a hash slot to a specific node
 *
 * Time complexity: O(1)

 * - Valid values for subcommand: "IMPORTING", "MIGRATING", "STABLE", "NODE"
 * Annotated return value: simple-string
 */
int NWNX_Redis_CLUSTER_SETSLOT(
	// Redis type: integer
	int slot,
	// Redis type: enum
	string subcommand,
	string node_id = ""
);

/**
 * CLUSTER_SLAVES
 *
 * List replica nodes of the specified master node
 *
 * Time complexity: O(1)
 * Annotated return value:
 */
int NWNX_Redis_CLUSTER_SLAVES(
	string node_id
);

/**
 * CLUSTER_REPLICAS
 *
 * List replica nodes of the specified master node
 *
 * Time complexity: O(1)
 * Annotated return value:
 */
int NWNX_Redis_CLUSTER_REPLICAS(
	string node_id
);

/**
 * CLUSTER_SLOTS
 *
 * Get array of Cluster slot to node mappings
 *
 * Time complexity: O(N) where N is the total number of Cluster nodes
 * Annotated return value: array
 */
int NWNX_Redis_CLUSTER_SLOTS();

/**
 * COMMAND
 *
 * Get array of Redis command details
 *
 * Time complexity: O(N) where N is the total number of Redis commands
 * Annotated return value: array
 */
int NWNX_Redis_COMMAND();

/**
 * COMMAND_COUNT
 *
 * Get total number of Redis commands
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_COMMAND_COUNT();

/**
 * COMMAND_GETKEYS
 *
 * Extract keys given a full Redis command
 *
 * Time complexity: O(N) where N is the number of arguments to the command
 * Annotated return value: array
 */
int NWNX_Redis_COMMAND_GETKEYS();

/**
 * COMMAND_INFO
 *
 * Get array of specific Redis command details
 *
 * Time complexity: O(N) when N is number of commands to look up
 * Annotated return value: array
 */
int NWNX_Redis_COMMAND_INFO(
	string command_name
);

/**
 * CONFIG_GET
 *
 * Get the value of a configuration parameter
 * Annotated return value: array
 */
int NWNX_Redis_CONFIG_GET(
	string parameter
);

/**
 * CONFIG_REWRITE
 *
 * Rewrite the configuration file with the in memory configuration
 * Annotated return value: simple-string
 */
int NWNX_Redis_CONFIG_REWRITE();

/**
 * CONFIG_SET
 *
 * Set a configuration parameter to the given value
 * Annotated return value: simple-string
 */
int NWNX_Redis_CONFIG_SET(
	string parameter,
	string value
);

/**
 * CONFIG_RESETSTAT
 *
 * Reset the stats returned by INFO
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_CONFIG_RESETSTAT();

/**
 * DBSIZE
 *
 * Return the number of keys in the selected database
 * Annotated return value: integer
 */
int NWNX_Redis_DBSIZE();

/**
 * DEBUG_OBJECT
 *
 * Get debugging information about a key
 * Annotated return value: simple-string
 */
int NWNX_Redis_DEBUG_OBJECT(
	string key
);

/**
 * DEBUG_SEGFAULT
 *
 * Make the server crash
 * Annotated return value: simple-string
 */
int NWNX_Redis_DEBUG_SEGFAULT();

/**
 * DECR
 *
 * Decrement the integer value of a key by one
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_DECR(
	string key
);

/**
 * DECRBY
 *
 * Decrement the integer value of a key by the given number
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_DECRBY(
	string key,
	// Redis type: integer
	int decrement
);

/**
 * DEL
 *
 * Delete a key
 *
 * Time complexity: O(N) where N is the number of keys that will be removed. When a key to
 * remove holds a value other than a string, the individual complexity for this
 * key is O(M) where M is the number of elements in the list, set, sorted set
 * or hash. Removing a single key that holds a string value is O(1).
 * Annotated return value: integer
 */
int NWNX_Redis_DEL(
	string key
);

/**
 * DISCARD
 *
 * Discard all commands issued after MULTI
 * Annotated return value: simple-string
 */
int NWNX_Redis_DISCARD();

/**
 * DUMP
 *
 * Return a serialized version of the value stored at the specified key.
 *
 * Time complexity: O(1) to access the key and additional O(N*M) to serialized it, where N is
 * the number of Redis objects composing the value and M their average size.
 * For small string values the time complexity is thus O(1)+O(1*M) where M is
 * small, so simply O(1).
 * Annotated return value: bulk-string
 */
int NWNX_Redis_DUMP(
	string key
);

/**
 * ECHO
 *
 * Echo the given string
 * Annotated return value: bulk-string
 */
int NWNX_Redis_ECHO(
	string message
);

/**
 * EVAL
 *
 * Execute a Lua script server side
 *
 * Time complexity: Depends on the script that is executed.
 * Annotated return value:
 */
int NWNX_Redis_EVAL(
	string script,
	// Redis type: integer
	int numkeys,
	string key,
	string arg
);

/**
 * EVALSHA
 *
 * Execute a Lua script server side
 *
 * Time complexity: Depends on the script that is executed.
 * Annotated return value:
 */
int NWNX_Redis_EVALSHA(
	string sha1,
	// Redis type: integer
	int numkeys,
	string key,
	string arg
);

/**
 * EXEC
 *
 * Execute all commands issued after MULTI
 * Annotated return value: array
 */
int NWNX_Redis_EXEC();

/**
 * EXISTS
 *
 * Determine if a key exists
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_EXISTS(
	string key
);

/**
 * EXPIRE
 *
 * Set a key's time to live in seconds
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_EXPIRE(
	string key,
	// Redis type: integer
	int seconds
);

/**
 * EXPIREAT
 *
 * Set the expiration for a key as a UNIX timestamp
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_EXPIREAT(
	string key,
	// Redis type: posix time
	string timestamp
);

/**
 * FLUSHALL
 *
 * Remove all keys from all databases

 * - Valid values for async: "ASYNC"
 * Annotated return value: simple-string
 */
int NWNX_Redis_FLUSHALL(
	// Redis type: enum
	string async = ""
);

/**
 * FLUSHDB
 *
 * Remove all keys from the current database

 * - Valid values for async: "ASYNC"
 * Annotated return value: simple-string
 */
int NWNX_Redis_FLUSHDB(
	// Redis type: enum
	string async = ""
);

/**
 * GEOADD
 *
 * Add one or more geospatial items in the geospatial index represented using a sorted set
 *
 * Time complexity: O(log(N)) for each item added, where N is the number of elements in the
 * sorted set.
 * Annotated return value: integer
 */
int NWNX_Redis_GEOADD(
	string key,
	// Redis type: double
	float longitude,
	// Redis type: double
	float latitude,
	string member
);

/**
 * GEOHASH
 *
 * Returns members of a geospatial index as standard geohash strings
 *
 * Time complexity: O(log(N)) for each member requested, where N is the number of elements in
 * the sorted set.
 * Annotated return value: array
 */
int NWNX_Redis_GEOHASH(
	string key,
	string member
);

/**
 * GEOPOS
 *
 * Returns longitude and latitude of members of a geospatial index
 *
 * Time complexity: O(log(N)) for each member requested, where N is the number of elements in
 * the sorted set.
 * Annotated return value: array
 */
int NWNX_Redis_GEOPOS(
	string key,
	string member
);

/**
 * GEODIST
 *
 * Returns the distance between two members of a geospatial index
 *
 * Time complexity: O(log(N))
 * Annotated return value: bulk-string
 */
int NWNX_Redis_GEODIST(
	string key,
	string member1,
	string member2,
	string unit = ""
);

/**
 * GEORADIUS
 *
 * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point
 *
 * Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the
 * circular area delimited by center and radius and M is the number of items
 * inside the index.

 * - Valid values for unit: "m", "km", "ft", "mi"

 * - Valid values for withcoord: "WITHCOORD"

 * - Valid values for withdist: "WITHDIST"

 * - Valid values for withhash: "WITHHASH"

 * - Valid values for order: "ASC", "DESC"
 * Annotated return value: array
 */
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 = ""
);

/**
 * GEORADIUSBYMEMBER
 *
 * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member
 *
 * Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the
 * circular area delimited by center and radius and M is the number of items
 * inside the index.

 * - Valid values for unit: "m", "km", "ft", "mi"

 * - Valid values for withcoord: "WITHCOORD"

 * - Valid values for withdist: "WITHDIST"

 * - Valid values for withhash: "WITHHASH"

 * - Valid values for order: "ASC", "DESC"
 * Annotated return value:
 */
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 = ""
);

/**
 * GET
 *
 * Get the value of a key
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_GET(
	string key
);

/**
 * GETBIT
 *
 * Returns the bit value at offset in the string value stored at key
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_GETBIT(
	string key,
	// Redis type: integer
	int offset
);

/**
 * GETRANGE
 *
 * Get a substring of the string stored at a key
 *
 * Time complexity: O(N) where N is the length of the returned string. The complexity is
 * ultimately determined by the returned length, but because creating a
 * substring from an existing string is very cheap, it can be considered O(1)
 * for small strings.
 * Annotated return value: bulk-string
 */
int NWNX_Redis_GETRANGE(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int end
);

/**
 * GETSET
 *
 * Set the string value of a key and return its old value
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_GETSET(
	string key,
	string value
);

/**
 * HDEL
 *
 * Delete one or more hash fields
 *
 * Time complexity: O(N) where N is the number of fields to be removed.
 * Annotated return value: integer
 */
int NWNX_Redis_HDEL(
	string key,
	string field
);

/**
 * HEXISTS
 *
 * Determine if a hash field exists
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HEXISTS(
	string key,
	string field
);

/**
 * HGET
 *
 * Get the value of a hash field
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_HGET(
	string key,
	string field
);

/**
 * HGETALL
 *
 * Get all the fields and values in a hash
 *
 * Time complexity: O(N) where N is the size of the hash.
 * Annotated return value: array
 */
int NWNX_Redis_HGETALL(
	string key
);

/**
 * HINCRBY
 *
 * Increment the integer value of a hash field by the given number
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HINCRBY(
	string key,
	string field,
	// Redis type: integer
	int increment
);

/**
 * HINCRBYFLOAT
 *
 * Increment the float value of a hash field by the given amount
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_HINCRBYFLOAT(
	string key,
	string field,
	// Redis type: double
	float increment
);

/**
 * HKEYS
 *
 * Get all the fields in a hash
 *
 * Time complexity: O(N) where N is the size of the hash.
 * Annotated return value: array
 */
int NWNX_Redis_HKEYS(
	string key
);

/**
 * HLEN
 *
 * Get the number of fields in a hash
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HLEN(
	string key
);

/**
 * HMGET
 *
 * Get the values of all the given hash fields
 *
 * Time complexity: O(N) where N is the number of fields being requested.
 * Annotated return value: array
 */
int NWNX_Redis_HMGET(
	string key,
	string field
);

/**
 * HMSET
 *
 * Set multiple hash fields to multiple values
 *
 * Time complexity: O(N) where N is the number of fields being set.
 * Annotated return value: simple-string
 */
int NWNX_Redis_HMSET(
	string key,
	string field,
	string value
);

/**
 * HSET
 *
 * Set the string value of a hash field
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HSET(
	string key,
	string field,
	string value
);

/**
 * HSETNX
 *
 * Set the value of a hash field, only if the field does not exist
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HSETNX(
	string key,
	string field,
	string value
);

/**
 * HSTRLEN
 *
 * Get the length of the value of a hash field
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_HSTRLEN(
	string key,
	string field
);

/**
 * HVALS
 *
 * Get all the values in a hash
 *
 * Time complexity: O(N) where N is the size of the hash.
 * Annotated return value: array
 */
int NWNX_Redis_HVALS(
	string key
);

/**
 * INCR
 *
 * Increment the integer value of a key by one
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_INCR(
	string key
);

/**
 * INCRBY
 *
 * Increment the integer value of a key by the given amount
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_INCRBY(
	string key,
	// Redis type: integer
	int increment
);

/**
 * INCRBYFLOAT
 *
 * Increment the float value of a key by the given amount
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_INCRBYFLOAT(
	string key,
	// Redis type: double
	float increment
);

/**
 * INFO
 *
 * Get information and statistics about the server
 * Annotated return value: bulk-string
 */
int NWNX_Redis_INFO(
	string section = ""
);

/**
 * KEYS
 *
 * Find all keys matching the given pattern
 *
 * Time complexity: O(N) with N being the number of keys in the database, under the assumption
 * that the key names in the database and the given pattern have limited
 * length.
 * Annotated return value: array
 */
int NWNX_Redis_KEYS(
	string pattern
);

/**
 * LASTSAVE
 *
 * Get the UNIX time stamp of the last successful save to disk
 * Annotated return value: integer
 */
int NWNX_Redis_LASTSAVE();

/**
 * LINDEX
 *
 * Get an element from a list by its index
 *
 * Time complexity: O(N) where N is the number of elements to traverse to get to the element at
 * index. This makes asking for the first or the last element of the list O(1).
 * Annotated return value: bulk-string
 */
int NWNX_Redis_LINDEX(
	string key,
	// Redis type: integer
	int index
);

/**
 * LINSERT
 *
 * Insert an element before or after another element in a list
 *
 * Time complexity: O(N) where N is the number of elements to traverse before seeing the value
 * pivot. This means that inserting somewhere on the left end on the list
 * (head) can be considered O(1) and inserting somewhere on the right end
 * (tail) is O(N).

 * - Valid values for where: "BEFORE", "AFTER"
 * Annotated return value: integer
 */
int NWNX_Redis_LINSERT(
	string key,
	// Redis type: enum
	string where,
	string pivot,
	string value
);

/**
 * LLEN
 *
 * Get the length of a list
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_LLEN(
	string key
);

/**
 * LPOP
 *
 * Remove and get the first element in a list
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_LPOP(
	string key
);

/**
 * LPUSH
 *
 * Prepend one or multiple values to a list
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_LPUSH(
	string key,
	string value
);

/**
 * LPUSHX
 *
 * Prepend a value to a list, only if the list exists
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_LPUSHX(
	string key,
	string value
);

/**
 * LRANGE
 *
 * Get a range of elements from a list
 *
 * Time complexity: O(S+N) where S is the distance of start offset from HEAD for small lists,
 * from nearest end (HEAD or TAIL) for large lists; and N is the number of
 * elements in the specified range.
 * Annotated return value: array
 */
int NWNX_Redis_LRANGE(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int stop
);

/**
 * LREM
 *
 * Remove elements from a list
 *
 * Time complexity: O(N) where N is the length of the list.
 * Annotated return value: integer
 */
int NWNX_Redis_LREM(
	string key,
	// Redis type: integer
	int count,
	string value
);

/**
 * LSET
 *
 * Set the value of an element in a list by its index
 *
 * Time complexity: O(N) where N is the length of the list. Setting either the first or the last
 * element of the list is O(1).
 * Annotated return value: simple-string
 */
int NWNX_Redis_LSET(
	string key,
	// Redis type: integer
	int index,
	string value
);

/**
 * LTRIM
 *
 * Trim a list to the specified range
 *
 * Time complexity: O(N) where N is the number of elements to be removed by the operation.
 * Annotated return value: simple-string
 */
int NWNX_Redis_LTRIM(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int stop
);

/**
 * MEMORY_DOCTOR
 *
 * Outputs memory problems report
 * Annotated return value: bulk-string
 */
int NWNX_Redis_MEMORY_DOCTOR();

/**
 * MEMORY_HELP
 *
 * Show helpful text about the different subcommands
 * Annotated return value: array
 */
int NWNX_Redis_MEMORY_HELP();

/**
 * MEMORY_MALLOC_STATS
 *
 * Show allocator internal stats
 * Annotated return value: bulk-string
 */
int NWNX_Redis_MEMORY_MALLOC_STATS();

/**
 * MEMORY_PURGE
 *
 * Ask the allocator to release memory
 * Annotated return value: simple-string
 */
int NWNX_Redis_MEMORY_PURGE();

/**
 * MEMORY_STATS
 *
 * Show memory usage details
 * Annotated return value: array
 */
int NWNX_Redis_MEMORY_STATS();

/**
 * MEMORY_USAGE
 *
 * Estimate the memory usage of a key
 *
 * Time complexity: O(N) where N is the number of samples.
 * Annotated return value: integer
 */
int NWNX_Redis_MEMORY_USAGE(
	string key,
	// Redis type: integer
	int samples_count = 0
);

/**
 * MGET
 *
 * Get the values of all the given keys
 *
 * Time complexity: O(N) where N is the number of keys to retrieve.
 * Annotated return value: array
 */
int NWNX_Redis_MGET(
	string key
);

/**
 * MIGRATE
 *
 * Atomically transfer a key from a Redis instance to another one.
 *
 * Time complexity: This command actually executes a DUMP+DEL in the source instance, and a
 * RESTORE in the target instance. See the pages of these commands for time
 * complexity. Also an O(N) data transfer between the two instances is
 * performed.

 * - Valid values for key: "key", "\"\""

 * - Valid values for copy: "COPY"

 * - Valid values for replace: "REPLACE"
 * Annotated return value: simple-string
 */
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 = ""
);

/**
 * MONITOR
 *
 * Listen for all requests received by the server in real time
 * Annotated return value:
 */
int NWNX_Redis_MONITOR();

/**
 * MOVE
 *
 * Move a key to another database
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_MOVE(
	string key,
	// Redis type: integer
	int db
);

/**
 * MSET
 *
 * Set multiple keys to multiple values
 *
 * Time complexity: O(N) where N is the number of keys to set.
 * Annotated return value: simple-string
 */
int NWNX_Redis_MSET(
	string key,
	string value
);

/**
 * MSETNX
 *
 * Set multiple keys to multiple values, only if none of the keys exist
 *
 * Time complexity: O(N) where N is the number of keys to set.
 * Annotated return value: integer
 */
int NWNX_Redis_MSETNX(
	string key,
	string value
);

/**
 * MULTI
 *
 * Mark the start of a transaction block
 * Annotated return value: simple-string
 */
int NWNX_Redis_MULTI();

/**
 * OBJECT
 *
 * Inspect the internals of Redis objects
 *
 * Time complexity: O(1) for all the currently implemented subcommands.
 * Annotated return value:
 */
int NWNX_Redis_OBJECT(
	string subcommand,
	string arguments = ""
);

/**
 * PERSIST
 *
 * Remove the expiration from a key
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_PERSIST(
	string key
);

/**
 * PEXPIRE
 *
 * Set a key's time to live in milliseconds
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_PEXPIRE(
	string key,
	// Redis type: integer
	int milliseconds
);

/**
 * PEXPIREAT
 *
 * Set the expiration for a key as a UNIX timestamp specified in milliseconds
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_PEXPIREAT(
	string key,
	// Redis type: posix time
	string milliseconds_timestamp
);

/**
 * PFADD
 *
 * Adds the specified elements to the specified HyperLogLog.
 *
 * Time complexity: O(1) to add every element.
 * Annotated return value: integer
 */
int NWNX_Redis_PFADD(
	string key,
	string element
);

/**
 * PFCOUNT
 *
 * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
 *
 * Time complexity: O(1) with a very small average constant time when called with a single key.
 * O(N) with N being the number of keys, and much bigger constant times, when
 * called with multiple keys.
 * Annotated return value: integer
 */
int NWNX_Redis_PFCOUNT(
	string key
);

/**
 * PFMERGE
 *
 * Merge N different HyperLogLogs into a single one.
 *
 * Time complexity: O(N) to merge N HyperLogLogs, but with high constant times.
 * Annotated return value: simple-string
 */
int NWNX_Redis_PFMERGE(
	// Redis type: key
	string destkey,
	// Redis type: key
	string sourcekey
);

/**
 * PING
 *
 * Ping the server
 * Annotated return value: simple-string
 */
int NWNX_Redis_PING(
	string message = ""
);

/**
 * PSETEX
 *
 * Set the value and expiration in milliseconds of a key
 *
 * Time complexity: O(1)
 * Annotated return value:
 */
int NWNX_Redis_PSETEX(
	string key,
	// Redis type: integer
	int milliseconds,
	string value
);

/**
 * PUBSUB
 *
 * Inspect the state of the Pub/Sub subsystem
 *
 * Time complexity: O(N) for the CHANNELS subcommand, where N is the number of active channels,
 * and assuming constant time pattern matching (relatively short channels and
 * patterns). O(N) for the NUMSUB subcommand, where N is the number of
 * requested channels. O(1) for the NUMPAT subcommand.
 * Annotated return value: array
 */
int NWNX_Redis_PUBSUB(
	string subcommand,
	string argument = ""
);

/**
 * PTTL
 *
 * Get the time to live for a key in milliseconds
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_PTTL(
	string key
);

/**
 * PUBLISH
 *
 * Post a message to a channel
 *
 * Time complexity: O(N+M) where N is the number of clients subscribed to the receiving channel
 * and M is the total number of subscribed patterns (by any client).
 * Annotated return value: integer
 */
int NWNX_Redis_PUBLISH(
	string channel,
	string message
);

/**
 * QUIT
 *
 * Close the connection
 * Annotated return value: simple-string
 */
int NWNX_Redis_QUIT();

/**
 * RANDOMKEY
 *
 * Return a random key from the keyspace
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_RANDOMKEY();

/**
 * READONLY
 *
 * Enables read queries for a connection to a cluster replica node
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_READONLY();

/**
 * READWRITE
 *
 * Disables read queries for a connection to a cluster replica node
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_READWRITE();

/**
 * RENAME
 *
 * Rename a key
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_RENAME(
	string key,
	// Redis type: key
	string newkey
);

/**
 * RENAMENX
 *
 * Rename a key, only if the new key does not exist
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_RENAMENX(
	string key,
	// Redis type: key
	string newkey
);

/**
 * RESTORE
 *
 * Create a key using the provided serialized value, previously obtained using DUMP.
 *
 * Time complexity: O(1) to create the new key and additional O(N*M) to reconstruct the
 * serialized value, where N is the number of Redis objects composing the value
 * and M their average size. For small string values the time complexity is
 * thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set
 * values the complexity is O(N*M*log(N)) because inserting values into sorted
 * sets is O(log(N)).

 * - Valid values for replace: "REPLACE"

 * - Valid values for absttl: "ABSTTL"
 * Annotated return value: simple-string
 */
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
);

/**
 * ROLE
 *
 * Return the role of the instance in the context of replication
 * Annotated return value: array
 */
int NWNX_Redis_ROLE();

/**
 * RPOP
 *
 * Remove and get the last element in a list
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_RPOP(
	string key
);

/**
 * RPOPLPUSH
 *
 * Remove the last element in a list, prepend it to another list and return it
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_RPOPLPUSH(
	// Redis type: key
	string source,
	// Redis type: key
	string destination
);

/**
 * RPUSH
 *
 * Append one or multiple values to a list
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_RPUSH(
	string key,
	string value
);

/**
 * RPUSHX
 *
 * Append a value to a list, only if the list exists
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_RPUSHX(
	string key,
	string value
);

/**
 * SADD
 *
 * Add one or more members to a set
 *
 * Time complexity: O(1) for each element added, so O(N) to add N elements when the command is
 * called with multiple arguments.
 * Annotated return value: integer
 */
int NWNX_Redis_SADD(
	string key,
	string member
);

/**
 * SAVE
 *
 * Synchronously save the dataset to disk
 * Annotated return value: simple-string
 */
int NWNX_Redis_SAVE();

/**
 * SCARD
 *
 * Get the number of members in a set
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_SCARD(
	string key
);

/**
 * SCRIPT_DEBUG
 *
 * Set the debug mode for executed scripts.
 *
 * Time complexity: O(1)

 * - Valid values for mode: "YES", "SYNC", "NO"
 * Annotated return value: simple-string
 */
int NWNX_Redis_SCRIPT_DEBUG(
	// Redis type: enum
	string mode
);

/**
 * SCRIPT_EXISTS
 *
 * Check existence of scripts in the script cache.
 *
 * Time complexity: O(N) with N being the number of scripts to check (so checking a single
 * script is an O(1) operation).
 * Annotated return value: array
 */
int NWNX_Redis_SCRIPT_EXISTS(
	string sha1
);

/**
 * SCRIPT_FLUSH
 *
 * Remove all the scripts from the script cache.
 *
 * Time complexity: O(N) with N being the number of scripts in cache
 * Annotated return value: simple-string
 */
int NWNX_Redis_SCRIPT_FLUSH();

/**
 * SCRIPT_KILL
 *
 * Kill the script currently in execution.
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_SCRIPT_KILL();

/**
 * SCRIPT_LOAD
 *
 * Load the specified Lua script into the script cache.
 *
 * Time complexity: O(N) with N being the length in bytes of the script body.
 * Annotated return value: bulk-string
 */
int NWNX_Redis_SCRIPT_LOAD(
	string script
);

/**
 * SDIFF
 *
 * Subtract multiple sets
 *
 * Time complexity: O(N) where N is the total number of elements in all given sets.
 * Annotated return value: array
 */
int NWNX_Redis_SDIFF(
	string key
);

/**
 * SDIFFSTORE
 *
 * Subtract multiple sets and store the resulting set in a key
 *
 * Time complexity: O(N) where N is the total number of elements in all given sets.
 * Annotated return value: integer
 */
int NWNX_Redis_SDIFFSTORE(
	// Redis type: key
	string destination,
	string key
);

/**
 * SELECT
 *
 * Change the selected database for the current connection
 * Annotated return value: simple-string
 */
int NWNX_Redis_SELECT(
	// Redis type: integer
	int index
);

/**
 * SET
 *
 * Set the string value of a key
 *
 * Time complexity: O(1)

 * - Valid values for condition: "NX", "XX"
 * Annotated return value: simple-string
 */
int NWNX_Redis_SET(
	string key,
	string value,
	// Redis type: enum
	string condition = ""
);

/**
 * SETBIT
 *
 * Sets or clears the bit at offset in the string value stored at key
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_SETBIT(
	string key,
	// Redis type: integer
	int offset,
	string value
);

/**
 * SETEX
 *
 * Set the value and expiration of a key
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_SETEX(
	string key,
	// Redis type: integer
	int seconds,
	string value
);

/**
 * SETNX
 *
 * Set the value of a key, only if the key does not exist
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_SETNX(
	string key,
	string value
);

/**
 * SETRANGE
 *
 * Overwrite part of a string at key starting at the specified offset
 *
 * Time complexity: O(1), not counting the time taken to copy the new string in place. Usually,
 * this string is very small so the amortized complexity is O(1). Otherwise,
 * complexity is O(M) with M being the length of the value argument.
 * Annotated return value: integer
 */
int NWNX_Redis_SETRANGE(
	string key,
	// Redis type: integer
	int offset,
	string value
);

/**
 * SHUTDOWN
 *
 * Synchronously save the dataset to disk and then shut down the server

 * - Valid values for save_mode: "NOSAVE", "SAVE"
 * Annotated return value: simple-string
 */
int NWNX_Redis_SHUTDOWN(
	// Redis type: enum
	string save_mode = ""
);

/**
 * SINTER
 *
 * Intersect multiple sets
 *
 * Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is
 * the number of sets.
 * Annotated return value: array
 */
int NWNX_Redis_SINTER(
	string key
);

/**
 * SINTERSTORE
 *
 * Intersect multiple sets and store the resulting set in a key
 *
 * Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is
 * the number of sets.
 * Annotated return value: integer
 */
int NWNX_Redis_SINTERSTORE(
	// Redis type: key
	string destination,
	string key
);

/**
 * SISMEMBER
 *
 * Determine if a given value is a member of a set
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_SISMEMBER(
	string key,
	string member
);

/**
 * SLAVEOF
 *
 * Make the server a replica of another instance, or promote it as master. Deprecated starting with Redis 5. Use REPLICAOF instead.
 * Annotated return value: simple-string
 */
int NWNX_Redis_SLAVEOF(
	string host,
	string port
);

/**
 * REPLICAOF
 *
 * Make the server a replica of another instance, or promote it as master.
 * Annotated return value: simple-string
 */
int NWNX_Redis_REPLICAOF(
	string host,
	string port
);

/**
 * SLOWLOG
 *
 * Manages the Redis slow queries log
 * Annotated return value:
 */
int NWNX_Redis_SLOWLOG(
	string subcommand,
	string argument = ""
);

/**
 * SMEMBERS
 *
 * Get all the members in a set
 *
 * Time complexity: O(N) where N is the set cardinality.
 * Annotated return value: array
 */
int NWNX_Redis_SMEMBERS(
	string key
);

/**
 * SMOVE
 *
 * Move a member from one set to another
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_SMOVE(
	// Redis type: key
	string source,
	// Redis type: key
	string destination,
	string member
);

/**
 * SORT
 *
 * Sort the elements in a list, set or sorted set
 *
 * Time complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort,
 * and M the number of returned elements. When the elements are not sorted,
 * complexity is currently O(N) as there is a copy step that will be avoided in
 * next releases.

 * - Valid values for order: "ASC", "DESC"

 * - Valid values for sorting: "ALPHA"
 * Annotated return value: array
 */
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 = ""
);

/**
 * SPOP
 *
 * Remove and return one or multiple random members from a set
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_SPOP(
	string key,
	// Redis type: integer
	int count = 0
);

/**
 * SRANDMEMBER
 *
 * Get one or multiple random members from a set
 *
 * Time complexity: Without the count argument O(1), otherwise O(N) where N is the absolute
 * value of the passed count.
 * Annotated return value: bulk-string
 */
int NWNX_Redis_SRANDMEMBER(
	string key,
	// Redis type: integer
	int count = 0
);

/**
 * SREM
 *
 * Remove one or more members from a set
 *
 * Time complexity: O(N) where N is the number of members to be removed.
 * Annotated return value: integer
 */
int NWNX_Redis_SREM(
	string key,
	string member
);

/**
 * STRLEN
 *
 * Get the length of the value stored in a key
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_STRLEN(
	string key
);

/**
 * SUNION
 *
 * Add multiple sets
 *
 * Time complexity: O(N) where N is the total number of elements in all given sets.
 * Annotated return value: array
 */
int NWNX_Redis_SUNION(
	string key
);

/**
 * SUNIONSTORE
 *
 * Add multiple sets and store the resulting set in a key
 *
 * Time complexity: O(N) where N is the total number of elements in all given sets.
 * Annotated return value: integer
 */
int NWNX_Redis_SUNIONSTORE(
	// Redis type: key
	string destination,
	string key
);

/**
 * SWAPDB
 *
 * Swaps two Redis databases
 * Annotated return value: simple-string
 */
int NWNX_Redis_SWAPDB(
	// Redis type: integer
	int index,
	// Redis type: integer
	int index_1
);

/**
 * SYNC
 *
 * Internal command used for replication
 * Annotated return value:
 */
int NWNX_Redis_SYNC();

/**
 * TIME
 *
 * Return the current server time
 *
 * Time complexity: O(1)
 * Annotated return value: array
 */
int NWNX_Redis_TIME();

/**
 * TOUCH
 *
 * Alters the last access time of a key(s). Returns the number of existing keys specified.
 *
 * Time complexity: O(N) where N is the number of keys that will be touched.
 * Annotated return value: integer
 */
int NWNX_Redis_TOUCH(
	string key
);

/**
 * TTL
 *
 * Get the time to live for a key
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_TTL(
	string key
);

/**
 * TYPE
 *
 * Determine the type stored at key
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_TYPE(
	string key
);

/**
 * UNLINK
 *
 * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
 *
 * Time complexity: O(1) for each key removed regardless of its size. Then the command does O(N)
 * work in a different thread in order to reclaim memory, where N is the number
 * of allocations the deleted objects where composed of.
 * Annotated return value: integer
 */
int NWNX_Redis_UNLINK(
	string key
);

/**
 * UNWATCH
 *
 * Forget about all watched keys
 *
 * Time complexity: O(1)
 * Annotated return value: simple-string
 */
int NWNX_Redis_UNWATCH();

/**
 * WAIT
 *
 * Wait for the synchronous replication of all the write commands sent in the context of the current connection
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_WAIT(
	// Redis type: integer
	int numreplicas,
	// Redis type: integer
	int timeout
);

/**
 * WATCH
 *
 * Watch the given keys to determine execution of the MULTI/EXEC block
 *
 * Time complexity: O(1) for every key.
 * Annotated return value: simple-string
 */
int NWNX_Redis_WATCH(
	string key
);

/**
 * ZADD
 *
 * Add one or more members to a sorted set, or update its score if it already exists
 *
 * Time complexity: O(log(N)) for each item added, where N is the number of elements in the
 * sorted set.

 * - Valid values for condition: "NX", "XX"

 * - Valid values for change: "CH"

 * - Valid values for increment: "INCR"
 * Annotated return value: integer
 */
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 = ""
);

/**
 * ZCARD
 *
 * Get the number of members in a sorted set
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_ZCARD(
	string key
);

/**
 * ZCOUNT
 *
 * Count the members in a sorted set with scores within the given values
 *
 * Time complexity: O(log(N)) with N being the number of elements in the sorted set.
 * Annotated return value: integer
 */
int NWNX_Redis_ZCOUNT(
	string key,
	// Redis type: double
	float min,
	// Redis type: double
	float max
);

/**
 * ZINCRBY
 *
 * Increment the score of a member in a sorted set
 *
 * Time complexity: O(log(N)) where N is the number of elements in the sorted set.
 * Annotated return value: bulk-string
 */
int NWNX_Redis_ZINCRBY(
	string key,
	// Redis type: integer
	int increment,
	string member
);

/**
 * ZINTERSTORE
 *
 * Intersect multiple sorted sets and store the resulting sorted set in a new key
 *
 * Time complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K
 * being the number of input sorted sets and M being the number of elements in
 * the resulting sorted set.

 * - Valid values for aggregate_aggregate: "SUM", "MIN", "MAX"
 * Annotated return value: integer
 */
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 = ""
);

/**
 * ZLEXCOUNT
 *
 * Count the number of members in a sorted set between a given lexicographical range
 *
 * Time complexity: O(log(N)) with N being the number of elements in the sorted set.
 * Annotated return value: integer
 */
int NWNX_Redis_ZLEXCOUNT(
	string key,
	string min,
	string max
);

/**
 * ZPOPMAX
 *
 * Remove and return members with the highest scores in a sorted set
 *
 * Time complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M
 * being the number of elements popped.
 * Annotated return value: array
 */
int NWNX_Redis_ZPOPMAX(
	string key,
	// Redis type: integer
	int count = 0
);

/**
 * ZPOPMIN
 *
 * Remove and return members with the lowest scores in a sorted set
 *
 * Time complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M
 * being the number of elements popped.
 * Annotated return value: array
 */
int NWNX_Redis_ZPOPMIN(
	string key,
	// Redis type: integer
	int count = 0
);

/**
 * ZRANGE
 *
 * Return a range of members in a sorted set, by index
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements returned.

 * - Valid values for withscores: "WITHSCORES"
 * Annotated return value: array
 */
int NWNX_Redis_ZRANGE(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int stop,
	// Redis type: enum
	string withscores = ""
);

/**
 * ZRANGEBYLEX
 *
 * Return a range of members in a sorted set, by lexicographical range
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements being returned. If M is constant (e.g. always asking for
 * the first 10 elements with LIMIT), you can consider it O(log(N)).
 * Annotated return value: array
 */
int NWNX_Redis_ZRANGEBYLEX(
	string key,
	string min,
	string max,
	// Redis type: integer
	int limit_offset = 0,
	// Redis type: integer
	int limit_count = 0
);

/**
 * ZREVRANGEBYLEX
 *
 * Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements being returned. If M is constant (e.g. always asking for
 * the first 10 elements with LIMIT), you can consider it O(log(N)).
 * Annotated return value: array
 */
int NWNX_Redis_ZREVRANGEBYLEX(
	string key,
	string max,
	string min,
	// Redis type: integer
	int limit_offset = 0,
	// Redis type: integer
	int limit_count = 0
);

/**
 * ZRANGEBYSCORE
 *
 * Return a range of members in a sorted set, by score
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements being returned. If M is constant (e.g. always asking for
 * the first 10 elements with LIMIT), you can consider it O(log(N)).

 * - Valid values for withscores: "WITHSCORES"
 * Annotated return value: array
 */
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
);

/**
 * ZRANK
 *
 * Determine the index of a member in a sorted set
 *
 * Time complexity: O(log(N))
 * Annotated return value: integer
 */
int NWNX_Redis_ZRANK(
	string key,
	string member
);

/**
 * ZREM
 *
 * Remove one or more members from a sorted set
 *
 * Time complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the
 * number of elements to be removed.
 * Annotated return value: integer
 */
int NWNX_Redis_ZREM(
	string key,
	string member
);

/**
 * ZREMRANGEBYLEX
 *
 * Remove all members in a sorted set between the given lexicographical range
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements removed by the operation.
 * Annotated return value: integer
 */
int NWNX_Redis_ZREMRANGEBYLEX(
	string key,
	string min,
	string max
);

/**
 * ZREMRANGEBYRANK
 *
 * Remove all members in a sorted set within the given indexes
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements removed by the operation.
 * Annotated return value: integer
 */
int NWNX_Redis_ZREMRANGEBYRANK(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int stop
);

/**
 * ZREMRANGEBYSCORE
 *
 * Remove all members in a sorted set within the given scores
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements removed by the operation.
 * Annotated return value: integer
 */
int NWNX_Redis_ZREMRANGEBYSCORE(
	string key,
	// Redis type: double
	float min,
	// Redis type: double
	float max
);

/**
 * ZREVRANGE
 *
 * Return a range of members in a sorted set, by index, with scores ordered from high to low
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements returned.

 * - Valid values for withscores: "WITHSCORES"
 * Annotated return value: array
 */
int NWNX_Redis_ZREVRANGE(
	string key,
	// Redis type: integer
	int start,
	// Redis type: integer
	int stop,
	// Redis type: enum
	string withscores = ""
);

/**
 * ZREVRANGEBYSCORE
 *
 * Return a range of members in a sorted set, by score, with scores ordered from high to low
 *
 * Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the
 * number of elements being returned. If M is constant (e.g. always asking for
 * the first 10 elements with LIMIT), you can consider it O(log(N)).

 * - Valid values for withscores: "WITHSCORES"
 * Annotated return value: array
 */
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
);

/**
 * ZREVRANK
 *
 * Determine the index of a member in a sorted set, with scores ordered from high to low
 *
 * Time complexity: O(log(N))
 * Annotated return value: integer
 */
int NWNX_Redis_ZREVRANK(
	string key,
	string member
);

/**
 * ZSCORE
 *
 * Get the score associated with the given member in a sorted set
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_ZSCORE(
	string key,
	string member
);

/**
 * ZUNIONSTORE
 *
 * Add multiple sorted sets and store the resulting sorted set in a new key
 *
 * Time complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets,
 * and M being the number of elements in the resulting sorted set.

 * - Valid values for aggregate_aggregate: "SUM", "MIN", "MAX"
 * Annotated return value: integer
 */
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 = ""
);

/**
 * SCAN
 *
 * Incrementally iterate the keys space
 *
 * Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command
 * calls for the cursor to return back to 0. N is the number of elements inside
 * the collection.
 * Annotated return value:
 */
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 = ""
);

/**
 * SSCAN
 *
 * Incrementally iterate Set elements
 *
 * Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command
 * calls for the cursor to return back to 0. N is the number of elements inside
 * the collection..
 * Annotated return value:
 */
int NWNX_Redis_SSCAN(
	string key,
	// Redis type: integer
	int cursor,
	// Redis type: pattern
	string match_pattern = "",
	// Redis type: integer
	int count_count = 0
);

/**
 * HSCAN
 *
 * Incrementally iterate hash fields and associated values
 *
 * Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command
 * calls for the cursor to return back to 0. N is the number of elements inside
 * the collection..
 * Annotated return value:
 */
int NWNX_Redis_HSCAN(
	string key,
	// Redis type: integer
	int cursor,
	// Redis type: pattern
	string match_pattern = "",
	// Redis type: integer
	int count_count = 0
);

/**
 * ZSCAN
 *
 * Incrementally iterate sorted sets elements and associated scores
 *
 * Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command
 * calls for the cursor to return back to 0. N is the number of elements inside
 * the collection..
 * Annotated return value:
 */
int NWNX_Redis_ZSCAN(
	string key,
	// Redis type: integer
	int cursor,
	// Redis type: pattern
	string match_pattern = "",
	// Redis type: integer
	int count_count = 0
);

/**
 * XINFO
 *
 * Get information on streams and consumer groups
 *
 * Time complexity: O(N) with N being the number of returned items for the subcommands CONSUMERS
 * and GROUPS. The STREAM subcommand is O(log N) with N being the number of
 * items in the stream.

 * - Valid values for help: "HELP"
 * Annotated return value:
 */
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 = ""
);

/**
 * XADD
 *
 * Appends a new entry to a stream
 *
 * Time complexity: O(1)
 * Annotated return value: bulk-string
 */
int NWNX_Redis_XADD(
	string key,
	string ID,
	// Redis type: value
	string field,
	string str
);

/**
 * XTRIM
 *
 * Trims the stream to (approximately if '~' is passed) a certain size
 *
 * Time complexity: O(N), with N being the number of evicted entries. Constant times are very
 * small however, since entries are organized in macro nodes containing
 * multiple entries that can be released with a single deallocation.

 * - Valid values for strategy: "MAXLEN"

 * - Valid values for approx: "~"
 * Annotated return value: integer
 */
int NWNX_Redis_XTRIM(
	string key,
	// Redis type: enum
	string strategy,
	// Redis type: enum
	string approx = "",
	// Redis type: integer
	int count = 0
);

/**
 * XDEL
 *
 * Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
 *
 * Time complexity: O(1) for each single item to delete in the stream, regardless of the stream
 * size.
 * Annotated return value: integer
 */
int NWNX_Redis_XDEL(
	string key,
	string ID
);

/**
 * XRANGE
 *
 * Return a range of elements in a stream, with IDs matching the specified IDs interval
 *
 * Time complexity: O(N) with N being the number of elements being returned. If N is constant
 * (e.g. always asking for the first 10 elements with COUNT), you can consider
 * it O(1).
 * Annotated return value: array
 */
int NWNX_Redis_XRANGE(
	string key,
	string start,
	string end,
	// Redis type: integer
	int count_count = 0
);

/**
 * XREVRANGE
 *
 * Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE
 *
 * Time complexity: O(N) with N being the number of elements returned. If N is constant (e.g.
 * always asking for the first 10 elements with COUNT), you can consider it
 * O(1).
 * Annotated return value: array
 */
int NWNX_Redis_XREVRANGE(
	string key,
	string end,
	string start,
	// Redis type: integer
	int count_count = 0
);

/**
 * XLEN
 *
 * Return the number of entires in a stream
 *
 * Time complexity: O(1)
 * Annotated return value: integer
 */
int NWNX_Redis_XLEN(
	string key
);

/**
 * XREAD
 *
 * Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.
 *
 * Time complexity: For each stream mentioned: O(N) with N being the number of elements being
 * returned, it menas that XREAD-ing with a fixed COUNT is O(1). Note that when
 * the BLOCK option is used, XADD will pay O(M) time in order to serve the M
 * clients blocked on the stream getting new data.

 * - Valid values for streams: "STREAMS"
 * Annotated return value: array
 */
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 = ""
);

/**
 * XGROUP
 *
 * Create, destroy, and manage consumer groups.
 *
 * Time complexity: O(1) for all the subcommands, with the exception of the DESTROY subcommand
 * which takes an additional O(M) time in order to delete the M entries inside
 * the consumer group pending entries list (PEL).
 * Annotated return value:
 */
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 = ""
);

/**
 * XREADGROUP
 *
 * Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.
 *
 * Time complexity: For each stream mentioned: O(M) with M being the number of elements
 * returned. If M is constant (e.g. always asking for the first 10 elements
 * with COUNT), you can consider it O(1). On the other side when XREADGROUP
 * blocks, XADD will pay the O(N) time in order to serve the N clients blocked
 * on the stream getting new data.

 * - Valid values for noack: "NOACK"

 * - Valid values for streams: "STREAMS"
 * Annotated return value:
 */
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 = ""
);

/**
 * XACK
 *
 * Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
 *
 * Time complexity: O(1) for each message ID processed.
 * Annotated return value: integer
 */
int NWNX_Redis_XACK(
	string key,
	string group,
	string ID
);

/**
 * XCLAIM
 *
 * Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
 *
 * Time complexity: O(log N) with N being the number of messages in the PEL of the consumer
 * group.
 * Annotated return value: array
 */
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
);

/**
 * XPENDING
 *
 * Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
 *
 * Time complexity: O(N) with N being the number of elements returned, so asking for a small
 * fixed number of entries per call is O(1). When the command returns just the
 * summary it runs in O(1) time assuming the list of consumers is small,
 * otherwise there is additional O(N) time needed to iterate every consumer.
 * Annotated return value: array
 */
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();
}

/// @}