Sid Gifari File Manager

Sid Gifari File Manager

🏠 Root / home / genremedia08 / musicjukebox.overlookedtracks.com / vendor / jetbrains / phpstorm-stubs / redis /

Editing: Redis.php

<?php

use JetBrains\PhpStorm\Deprecated;

/**
 * Helper autocomplete for php redis extension
 *
 * @author Max Kamashev <max.kamashev@gmail.com>
 * @link https://github.com/ukko/phpredis-phpdoc
 */
class Redis
{
 public const AFTER = 'after';
 public const BEFORE = 'before';

/**
     * Options
     */
    public const OPT_SERIALIZER = 1;
    public const OPT_PREFIX = 2;
    public const OPT_READ_TIMEOUT = 3;
    public const OPT_SCAN = 4;
    public const OPT_FAILOVER = 5;
    public const OPT_TCP_KEEPALIVE = 6;
    public const OPT_COMPRESSION = 7;
    public const OPT_REPLY_LITERAL = 8;
    public const OPT_COMPRESSION_LEVEL = 9;
    public const OPT_MAX_RETRIES = 11;
    public const OPT_BACKOFF_ALGORITHM = 12;
    public const OPT_BACKOFF_BASE = 13;
    public const OPT_BACKOFF_CAP = 14;

/**
     * Cluster options
     */
    public const FAILOVER_NONE = 0;
    public const FAILOVER_ERROR = 1;
    public const FAILOVER_DISTRIBUTE = 2;
    public const FAILOVER_DISTRIBUTE_SLAVES = 3;

/**
     * SCAN options
     */
    public const SCAN_NORETRY = 0;
    public const SCAN_RETRY = 1;

/**
     * @since 5.3.0
     */
    public const SCAN_PREFIX = 2;

/**
     * @since 5.3.0
     */
    public const SCAN_NOPREFIX = 3;

/**
     * Serializers
     */
    public const SERIALIZER_NONE = 0;
    public const SERIALIZER_PHP = 1;
    public const SERIALIZER_IGBINARY = 2;
    public const SERIALIZER_MSGPACK = 3;
    public const SERIALIZER_JSON = 4;

/**
     * Compressions
     */
    public const COMPRESSION_NONE = 0;
    public const COMPRESSION_LZF = 1;
    public const COMPRESSION_ZSTD = 2;
    public const COMPRESSION_LZ4 = 3;

/**
     * Compression ZSTD levels
     */
    public const COMPRESSION_ZSTD_MIN = 1;
    public const COMPRESSION_ZSTD_DEFAULT = 3;
    public const COMPRESSION_ZSTD_MAX = 22;

/**
     * Multi
     */
    public const ATOMIC = 0;
    public const MULTI = 1;
    public const PIPELINE = 2;

/**
     * Type
     */
    public const REDIS_NOT_FOUND = 0;
    public const REDIS_STRING = 1;
    public const REDIS_SET = 2;
    public const REDIS_LIST = 3;
    public const REDIS_ZSET = 4;
    public const REDIS_HASH = 5;
    public const REDIS_STREAM = 6;

/**
     * Backoff algorithms
     * @since 5.3.5
     */
    public const BACKOFF_ALGORITHM_DEFAULT = 0;
    public const BACKOFF_ALGORITHM_DECORRELATED_JITTER = 1;
    public const BACKOFF_ALGORITHM_FULL_JITTER = 2;
    public const BACKOFF_ALGORITHM_EQUAL_JITTER = 3;
    public const BACKOFF_ALGORITHM_EXPONENTIAL = 4;
    public const BACKOFF_ALGORITHM_UNIFORM = 5;
    public const BACKOFF_ALGORITHM_CONSTANT = 6;

/**
     * Creates a Redis client
     *
     * @example $redis = new Redis();
     */
    public function __construct() {}

/**
 * Connects to a Redis instance.
 *
 * @param string $host can be a host, or the path to a unix domain socket
 * @param int $port optional
 * @param float $timeout value in seconds (optional, default is 0.0 meaning unlimited)
 * @param null $reserved should be null if $retryInterval is specified
 * @param int $retry_interval retry interval in milliseconds.
 * @param float $read_timeout value in seconds (optional, default is 0 meaning unlimited)
 *
 * @return bool TRUE on success, FALSE on error
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->connect('127.0.0.1', 6379);
 * $redis->connect('127.0.0.1'); // port 6379 by default
 * $redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
 * $redis->connect('/tmp/redis.sock'); // unix domain socket.
 * </pre>
 */
 public function connect(
 $host,
 $port = 6379,
 $timeout = 0.0,
 $reserved = null,
 $retry_interval = 0,
 $read_timeout = 0.0
 ) {}

/**
     * Connects to a Redis instance.
     *
     * @param string $host          can be a host, or the path to a unix domain socket
     * @param int    $port          optional
     * @param float  $timeout       value in seconds (optional, default is 0.0 meaning unlimited)
     * @param null   $reserved      should be null if $retry_interval is specified
     * @param int    $retryInterval retry interval in milliseconds.
     * @param float  $readTimeout   value in seconds (optional, default is 0 meaning unlimited)
     *
     * @return bool TRUE on success, FALSE on error
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->connect(%parametersList%)')]
    public function open(
        $host,
        $port = 6379,
        $timeout = 0.0,
        $reserved = null,
        $retryInterval = 0,
        $readTimeout = 0.0
    ) {}

/**
     * A method to determine if a phpredis object thinks it's connected to a server
     *
     * @return bool Returns TRUE if phpredis thinks it's connected and FALSE if not
     *
     * @throws RedisException
     */
    public function isConnected() {}

/**
     * Retrieve our host or unix socket that we're connected to
     *
     * @return string|false The host or unix socket we're connected to or FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getHost() {}

/**
     * Get the port we're connected to
     *
     * @return int|false Returns the port we're connected to or FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getPort() {}

/**
     * Get the database number phpredis is pointed to
     *
     * @return int|bool Returns the database number (int) phpredis thinks it's pointing to
     * or FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getDbNum() {}

/**
     * Get the (write) timeout in use for phpredis
     *
     * @return float|false The timeout (DOUBLE) specified in our connect call or FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getTimeout() {}

/**
     * Get the read timeout specified to phpredis or FALSE if we're not connected
     *
     * @return float|bool Returns the read timeout (which can be set using setOption and Redis::OPT_READ_TIMEOUT)
     * or FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getReadTimeout() {}

/**
     * Gets the persistent ID that phpredis is using
     *
     * @return string|null|bool Returns the persistent id phpredis is using
     * (which will only be set if connected with pconnect),
     * NULL if we're not using a persistent ID,
     * and FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getPersistentID() {}

/**
     * Get the password used to authenticate the phpredis connection
     *
     * @return string|null|bool Returns the password used to authenticate a phpredis session or NULL if none was used,
     * and FALSE if we're not connected
     *
     * @throws RedisException
     */
    public function getAuth() {}

/**
 * Connects to a Redis instance or reuse a connection already established with pconnect/popen.
 *
 * The connection will not be closed on close or end of request until the php process ends.
 * So be patient on to many open FD's (specially on redis server side) when using persistent connections on
 * many servers connecting to one redis server.
 *
 * Also more than one persistent connection can be made identified by either host + port + timeout
 * or host + persistentId or unix socket + timeout.
 *
 * This feature is not available in threaded versions. pconnect and popen then working like their non persistent
 * equivalents.
 *
 * @param string $host can be a host, or the path to a unix domain socket
 * @param int $port optional
 * @param float $timeout value in seconds (optional, default is 0 meaning unlimited)
 * @param string $persistentId identity for the requested persistent connection
 * @param int $retryInterval retry interval in milliseconds.
 * @param float $readTimeout value in seconds (optional, default is 0 meaning unlimited)
 *
 * @return bool TRUE on success, FALSE on ertcnror.
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->pconnect('127.0.0.1', 6379);
 *
 * // port 6379 by default - same connection like before
 * $redis->pconnect('127.0.0.1');
 *
 * // 2.5 sec timeout and would be another connection than the two before.
 * $redis->pconnect('127.0.0.1', 6379, 2.5);
 *
 * // x is sent as persistent_id and would be another connection than the three before.
 * $redis->pconnect('127.0.0.1', 6379, 2.5, 'x');
 *
 * // unix domain socket - would be another connection than the four before.
 * $redis->pconnect('/tmp/redis.sock');
 * </pre>
 */
 public function pconnect(
 $host,
 $port = 6379,
 $timeout = 0.0,
 $persistentId = null,
 $retryInterval = 0,
 $readTimeout = 0.0
 ) {}

/**
     * @param string $host
     * @param int    $port
     * @param float  $timeout
     * @param string $persistentId
     * @param int    $retryInterval
     * @param float  $readTimeout
     *
     * @return bool
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->pconnect(%parametersList%)')]
    public function popen(
        $host,
        $port = 6379,
        $timeout = 0.0,
        $persistentId = '',
        $retryInterval = 0,
        $readTimeout = 0.0
    ) {}

/**
     * Disconnects from the Redis instance.
     *
     * Note: Closing a persistent connection requires PhpRedis >= 4.2.0
     *
     * @since >= 4.2 Closing a persistent connection requires PhpRedis
     *
     * @return bool TRUE on success, FALSE on error
     *
     * @throws RedisException
     */
    public function close() {}

/**
 * Swap one Redis database with another atomically
 *
 * Note: Requires Redis >= 4.0.0
 *
 * @param int $db1
 * @param int $db2
 *
 * @return bool TRUE on success and FALSE on failure
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/swapdb
 * @since >= 4.0
 * @example
 * <pre>
 * // Swaps DB 0 with DB 1 atomically
 * $redis->swapdb(0, 1);
 * </pre>
 */
 public function swapdb(int $db1, int $db2) {}

/**
 * Set client option
 *
 * @param int $option option name
 * @param mixed $value option value
 *
 * @return bool TRUE on success, FALSE on error
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // don't serialize data
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP); // use built-in serialize/unserialize
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // use igBinary serialize/unserialize
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_MSGPACK); // Use msgpack serialize/unserialize
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON); // Use json serialize/unserialize
 *
 * $redis->setOption(Redis::OPT_PREFIX, 'myAppName:'); // use custom prefix on all keys
 *
 * // Options for the SCAN family of commands, indicating whether to abstract
 * // empty results from the user. If set to SCAN_NORETRY (the default), phpredis
 * // will just issue one SCAN command at a time, sometimes returning an empty
 * // array of results. If set to SCAN_RETRY, phpredis will retry the scan command
 * // until keys come back OR Redis returns an iterator of zero
 * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
 * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
 * </pre>
 */
 public function setOption($option, $value) {}

/**
     * Get client option
     *
     * @param int $option parameter name
     *
     * @return mixed|null Parameter value
     *
     * @throws RedisException
     *
     * @see setOption()
     * @example
     * // return option value
     * $redis->getOption(Redis::OPT_SERIALIZER);
     */
    public function getOption($option) {}

/**
     * Check the current connection status
     *
     * @param string $message [optional]
     *
     * @return bool|string TRUE if the command is successful or returns message
     * Throws a RedisException object on connectivity error, as described above.
     * @throws RedisException
     * @link    https://redis.io/commands/ping
     */
    public function ping($message = null) {}

/**
     * Echo the given string
     *
     * @param string $message
     *
     * @return string|Redis Returns message or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/echo
     */
    public function echo($message) {}

/**
 * Get the value related to the specified key
 *
 * @param string $key
 *
 * @return string|mixed|false|Redis If key didn't exist, FALSE is returned or Redis if in multi mode
 * Otherwise, the value related to this key is returned
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/get
 * @example
 * <pre>
 * $redis->set('key', 'hello');
 * $redis->get('key');
 *
 * // set and get with serializer
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON);
 *
 * $redis->set('key', ['asd' => 'as', 'dd' => 123, 'b' => true]);
 * var_dump($redis->get('key'));
 * // Output:
 * array(3) {
 * 'asd' => string(2) "as"
 * 'dd' => int(123)
 * 'b' => bool(true)
 * }
 * </pre>
 */
 public function get($key) {}

/**
 * Set the string value in argument as value of the key.
 *
 * @since If you're using Redis >= 2.6.12, you can pass extended options as explained in example
 *
 * @param string $key
 * @param string|mixed $value string if not used serializer
 * @param int|array $timeout [optional] Calling setEx() is preferred if you want a timeout. 
 * Since 2.6.12 it also supports different flags inside an array. Example ['NX', 'EX' => 60] 
 * - EX seconds -- Set the specified expire time, in seconds. 
 * - PX milliseconds -- Set the specified expire time, in milliseconds. 
 * - NX -- Only set the key if it does not already exist. 
 * - XX -- Only set the key if it already exist. 
 * <pre>
 * // Simple key -> value set
 * $redis->set('key', 'value');
 *
 * // Will redirect, and actually make an SETEX call
 * $redis->set('key','value', 10);
 *
 * // Will set the key, if it doesn't exist, with a ttl of 10 seconds
 * $redis->set('key', 'value', ['nx', 'ex' => 10]);
 *
 * // Will set a key, if it does exist, with a ttl of 1000 milliseconds
 * $redis->set('key', 'value', ['xx', 'px' => 1000]);
 * </pre>
 *
 * @return bool|Redis TRUE if the command is successful or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/set
 */
 public function set($key, $value, $timeout = null) {}

/**
     * Set the string value in argument as value of the key, with a time to live.
     *
     * @param string       $key
     * @param int          $expire
     * @param string|mixed $value
     *
     * @return bool|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/setex
     * @example $redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
     */
    public function setex($key, $expire, $value) {}

/**
     * Set the value and expiration in milliseconds of a key.
     *
     * @see     setex()
     * @param   string       $key
     * @param   int          $expire in milliseconds.
     * @param   string|mixed $value
     *
     * @return bool|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/psetex
     * @example $redis->psetex('key', 1000, 'value'); // sets key → value, with 1sec TTL.
     */
    public function psetex($key, $expire, $value) {}

/**
 * Set the string value in argument as value of the key if the key doesn't already exist in the database.
 *
 * @param string $key
 * @param mixed $value
 *
 * @return bool|array|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/setnx
 * @example
 * <pre>
 * $redis->setnx('key', 'value'); // return TRUE
 * $redis->setnx('key', 'value'); // return FALSE
 * </pre>
 */
 public function setnx($key, $value) {}

/**
 * Remove specified keys.
 *
 * @param int|string|array $key1 An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN
 * @param int|string ...$otherKeys
 *
 * @return int|Redis Number of keys deleted or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/del
 * @example
 * <pre>
 * $redis->set('key1', 'val1');
 * $redis->set('key2', 'val2');
 * $redis->set('key3', 'val3');
 * $redis->set('key4', 'val4');
 *
 * $redis->del('key1', 'key2'); // return 2
 * $redis->del(['key3', 'key4']); // return 2
 * </pre>
 */
 public function del($key1, ...$otherKeys) {}

/**
     * @param   string|string[] $key1
     * @param   string          $key2
     * @param   string          $key3
     *
     * @return int|Redis Number of keys deleted or Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: "%class%->del(%parametersList%)")]
    public function delete($key1, $key2 = null, $key3 = null) {}

/**
 * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
 *
 * @see del()
 * @param string|string[] $key1
 * @param string $key2
 * @param string $key3
 *
 * @return int|Redis Number of keys unlinked or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/unlink
 * @example
 * <pre>
 * $redis->set('key1', 'val1');
 * $redis->set('key2', 'val2');
 * $redis->set('key3', 'val3');
 * $redis->set('key4', 'val4');
 * $redis->unlink('key1', 'key2'); // return 2
 * $redis->unlink(array('key3', 'key4')); // return 2
 * </pre>
 */
 public function unlink($key1, $key2 = null, $key3 = null) {}

/**
 * Enter and exit transactional mode.
 *
 * @param int $mode Redis::MULTI|Redis::PIPELINE
 * Defaults to Redis::MULTI.
 * A Redis::MULTI block of commands runs as a single transaction;
 * a Redis::PIPELINE block is simply transmitted faster to the server, but without any guarantee of atomicity.
 * discard cancels a transaction.
 *
 * @return static|Redis returns the Redis instance and enters multi-mode or Redis if in multi mode
 * Once in multi-mode, all subsequent method calls return the same object until exec() is called.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/multi
 * @example
 * <pre>
 * $ret = $redis->multi()
 * ->set('key1', 'val1')
 * ->get('key1')
 * ->set('key2', 'val2')
 * ->get('key2')
 * ->exec();
 *
 * //$ret == array (
 * // 0 => TRUE,
 * // 1 => 'val1',
 * // 2 => TRUE,
 * // 3 => 'val2');
 * </pre>
 */
 public function multi($mode = Redis::MULTI) {}

/**
 * Returns a Redis instance which can simply transmitted faster to the server.
 *
 * @return Redis returns the Redis instance.
 * Once in pipeline-mode, all subsequent method calls return the same object until exec() is called.
 * Pay attention, that Pipeline is not a transaction, so you can get unexpected
 * results in case of big pipelines and small read/write timeouts.
 *
 * @throws RedisException
 *
 * @link https://redis.io/topics/pipelining
 * @example
 * <pre>
 * $ret = $this->redis->pipeline()
 * ->ping()
 * ->multi()->set('x', 42)->incr('x')->exec()
 * ->ping()
 * ->multi()->get('x')->del('x')->exec()
 * ->ping()
 * ->exec();
 *
 * //$ret == array (
 * // 0 => '+PONG',
 * // 1 => [TRUE, 43],
 * // 2 => '+PONG',
 * // 3 => [43, 1],
 * // 4 => '+PONG');
 * </pre>
 */
 public function pipeline() {}

/**
     * @return void|array|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     *
     * @see multi()
     * @link https://redis.io/commands/exec
     */
    public function exec() {}

/**
     * @throws RedisException
     *
     * @see multi()
     * @link https://redis.io/commands/discard
     */
    public function discard() {}

/**
 * Watches a key for modifications by another client. If the key is modified between WATCH and EXEC,
 * the MULTI/EXEC transaction will fail (return FALSE). unwatch cancels all the watching of all keys by this client.
 * @param string|string[] $key a list of keys
 *
 * @return void|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/watch
 * @example
 * <pre>
 * $redis->watch('x');
 * // long code here during the execution of which other clients could well modify `x`
 * $ret = $redis->multi()
 * ->incr('x')
 * ->exec();
 * // $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
 * </pre>
 */
 public function watch($key) {}

/**
     * @throws RedisException
     *
     * @see watch()
     * @link    https://redis.io/commands/unwatch
     */
    public function unwatch() {}

/**
 * Subscribe to channels.
 *
 * Warning: this function will probably change in the future.
 *
 * @param string[] $channels an array of channels to subscribe
 * @param string|array $callback either a string or an array($instance, 'method_name').
 * The callback function receives 3 parameters: the redis instance, the channel name, and the message.
 *
 * @return mixed|null|Redis Any non-null return value in the callback will be returned to the caller or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/subscribe
 * @example
 * <pre>
 * function f($redis, $chan, $msg) {
 * switch($chan) {
 * case 'chan-1':
 * ...
 * break;
 *
 * case 'chan-2':
 * ...
 * break;
 *
 * case 'chan-2':
 * ...
 * break;
 * }
 * }
 *
 * $redis->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f'); // subscribe to 3 chans
 * </pre>
 */
 public function subscribe($channels, $callback) {}

/**
 * Subscribe to channels by pattern
 *
 * @param array $patterns an array of glob-style patterns to subscribe
 * @param string|array $callback Either a string or an array with an object and method.
 * The callback will get four arguments ($redis, $pattern, $channel, $message)
 * @return mixed|Redis Any non-null return value in the callback will be returned to the caller or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/psubscribe
 * @example
 * <pre>
 * function psubscribe($redis, $pattern, $chan, $msg) {
 * echo "Pattern: $pattern\n";
 * echo "Channel: $chan\n";
 * echo "Payload: $msg\n";
 * }
 * </pre>
 */
 public function psubscribe($patterns, $callback) {}

/**
     * Publish messages to channels.
     *
     * Warning: this function will probably change in the future.
     *
     * @param string $channel a channel to publish to
     * @param string $message string
     *
     * @return int|Redis Number of clients that received the message or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/publish
     * @example $redis->publish('chan-1', 'hello, world!'); // send message.
     */
    public function publish($channel, $message) {}

/**
 * A command allowing you to get information on the Redis pub/sub system
 *
 * @param string $keyword String, which can be: "channels", "numsub", or "numpat"
 * @param string|array $argument Optional, variant.
 * For the "channels" subcommand, you can pass a string pattern.
 * For "numsub" an array of channel names
 *
 * @return array|int|Redis Either an integer or an array or Redis if in multi mode
 * - channels Returns an array where the members are the matching channels.
 * - numsub Returns a key/value array where the keys are channel names and
 * values are their counts.
 * - numpat Integer return containing the number active pattern subscriptions
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pubsub
 * @example
 * <pre>
 * $redis->pubsub('channels'); // All channels
 * $redis->pubsub('channels', '*pattern*'); // Just channels matching your pattern
 * $redis->pubsub('numsub', array('chan1', 'chan2')); // Get subscriber counts for 'chan1' and 'chan2'
 * $redis->pubsub('numpat'); // Get the number of pattern subscribers
 * </pre>
 */
 public function pubsub($keyword, $argument) {}

/**
     * Stop listening for messages posted to the given channels.
     *
     * @param array $channels an array of channels to usubscribe
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/unsubscribe
     */
    public function unsubscribe($channels = null) {}

/**
     * Stop listening for messages posted to the given channels.
     *
     * @param array $patterns   an array of glob-style patterns to unsubscribe
     *
     * @throws RedisException
     *
     * @link https://redis.io/commands/punsubscribe
     */
    public function punsubscribe($patterns = null) {}

/**
 * Verify if the specified key/keys exists
 *
 * This function took a single argument and returned TRUE or FALSE in phpredis versions < 4.0.0.
 *
 * @since >= 4.0 Returned int, if < 4.0 returned bool
 *
 * @param string|string[] $key
 *
 * @return int|bool|Redis The number of keys tested that do exist or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/exists
 * @link https://github.com/phpredis/phpredis#exists
 * @example
 * <pre>
 * $redis->exists('key'); // 1
 * $redis->exists('NonExistingKey'); // 0
 *
 * $redis->mset(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
 * $redis->exists(['foo', 'bar', 'baz]); // 3
 * $redis->exists('foo', 'bar', 'baz'); // 3
 * </pre>
 */
 public function exists($key) {}

/**
 * Increment the number stored at key by one.
 *
 * @param string $key
 *
 * @return int|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/incr
 * @example
 * <pre>
 * $redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
 * $redis->incr('key1'); // 2
 * $redis->incr('key1'); // 3
 * $redis->incr('key1'); // 4
 * </pre>
 */
 public function incr($key) {}

/**
 * Increment the float value of a key by the given amount
 *
 * @param string $key
 * @param float $increment
 *
 * @return float|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/incrbyfloat
 * @example
 * <pre>
 * $redis->set('x', 3);
 * $redis->incrByFloat('x', 1.5); // float(4.5)
 * $redis->get('x'); // float(4.5)
 * </pre>
 */
 public function incrByFloat($key, $increment) {}

/**
 * Increment the number stored at key by one.
 * If the second argument is filled, it will be used as the integer value of the increment.
 *
 * @param string $key key
 * @param int $value value that will be added to key (only for incrBy)
 *
 * @return int|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/incrby
 * @example
 * <pre>
 * $redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
 * $redis->incr('key1'); // 2
 * $redis->incr('key1'); // 3
 * $redis->incr('key1'); // 4
 * $redis->incrBy('key1', 10); // 14
 * </pre>
 */
 public function incrBy($key, $value) {}

/**
 * Decrement the number stored at key by one.
 *
 * @param string $key
 *
 * @return int|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/decr
 * @example
 * <pre>
 * $redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
 * $redis->decr('key1'); // -2
 * $redis->decr('key1'); // -3
 * </pre>
 */
 public function decr($key) {}

/**
 * Decrement the number stored at key by one.
 * If the second argument is filled, it will be used as the integer value of the decrement.
 *
 * @param string $key
 * @param int $value that will be subtracted to key (only for decrBy)
 *
 * @return int|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/decrby
 * @example
 * <pre>
 * $redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
 * $redis->decr('key1'); // -2
 * $redis->decr('key1'); // -3
 * $redis->decrBy('key1', 10); // -13
 * </pre>
 */
 public function decrBy($key, $value) {}

/**
 * Adds the string values to the head (left) of the list.
 * Creates the list if the key didn't exist.
 * If the key exists and is not a list, FALSE is returned.
 *
 * @param string $key
 * @param string|mixed ...$value1 Variadic list of values to push in key, if dont used serialized, used string
 *
 * @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lpush
 * @example
 * <pre>
 * $redis->lPush('l', 'v1', 'v2', 'v3', 'v4') // int(4)
 * var_dump( $redis->lRange('l', 0, -1) );
 * // Output:
 * // array(4) {
 * // [0]=> string(2) "v4"
 * // [1]=> string(2) "v3"
 * // [2]=> string(2) "v2"
 * // [3]=> string(2) "v1"
 * // }
 * </pre>
 */
 public function lPush($key, ...$value1) {}

/**
 * Adds the string values to the tail (right) of the list.
 * Creates the list if the key didn't exist.
 * If the key exists and is not a list, FALSE is returned.
 *
 * @param string $key
 * @param string|mixed ...$value1 Variadic list of values to push in key, if dont used serialized, used string
 *
 * @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/rpush
 * @example
 * <pre>
 * $redis->rPush('l', 'v1', 'v2', 'v3', 'v4'); // int(4)
 * var_dump( $redis->lRange('l', 0, -1) );
 * // Output:
 * // array(4) {
 * // [0]=> string(2) "v1"
 * // [1]=> string(2) "v2"
 * // [2]=> string(2) "v3"
 * // [3]=> string(2) "v4"
 * // }
 * </pre>
 */
 public function rPush($key, ...$value1) {}

/**
 * Adds the string value to the head (left) of the list if the list exists.
 *
 * @param string $key
 * @param string|mixed $value String, value to push in key
 *
 * @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lpushx
 * @example
 * <pre>
 * $redis->del('key1');
 * $redis->lPushx('key1', 'A'); // returns 0
 * $redis->lPush('key1', 'A'); // returns 1
 * $redis->lPushx('key1', 'B'); // returns 2
 * $redis->lPushx('key1', 'C'); // returns 3
 * // key1 now points to the following list: [ 'A', 'B', 'C' ]
 * </pre>
 */
 public function lPushx($key, $value) {}

/**
 * Adds the string value to the tail (right) of the list if the ist exists. FALSE in case of Failure.
 *
 * @param string $key
 * @param string|mixed $value String, value to push in key
 *
 * @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/rpushx
 * @example
 * <pre>
 * $redis->del('key1');
 * $redis->rPushx('key1', 'A'); // returns 0
 * $redis->rPush('key1', 'A'); // returns 1
 * $redis->rPushx('key1', 'B'); // returns 2
 * $redis->rPushx('key1', 'C'); // returns 3
 * // key1 now points to the following list: [ 'A', 'B', 'C' ]
 * </pre>
 */
 public function rPushx($key, $value) {}

/**
 * Returns and removes the first element of the list.
 *
 * @param string $key
 *
 * @return mixed|bool|Redis if command executed successfully BOOL FALSE in case of failure (empty list) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lpop
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
 * $redis->lPop('key1'); // key1 => [ 'B', 'C' ]
 * </pre>
 */
 public function lPop($key) {}

/**
 * Returns and removes the last element of the list.
 *
 * @param string $key
 *
 * @return mixed|bool|Redis if command executed successfully BOOL FALSE in case of failure (empty list) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/rpop
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
 * $redis->rPop('key1'); // key1 => [ 'A', 'B' ]
 * </pre>
 */
 public function rPop($key) {}

/**
 * Is a blocking lPop primitive. If at least one of the lists contains at least one element,
 * the element will be popped from the head of the list and returned to the caller.
 * Il all the list identified by the keys passed in arguments are empty, blPop will block
 * during the specified timeout until an element is pushed to one of those lists. This element will be popped.
 *
 * @param string|string[] $keys String array containing the keys of the lists OR variadic list of strings
 * @param int $timeout Timeout is always the required final parameter
 *
 * @return array|Redis ['listName', 'element'] or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/blpop
 * @example
 * <pre>
 * // Non blocking feature
 * $redis->lPush('key1', 'A');
 * $redis->del('key2');
 *
 * $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
 * // OR
 * $redis->blPop(['key1', 'key2'], 10); // array('key1', 'A')
 *
 * $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
 * // OR
 * $redis->brPop(['key1', 'key2'], 10); // array('key1', 'A')
 *
 * // Blocking feature
 *
 * // process 1
 * $redis->del('key1');
 * $redis->blPop('key1', 10);
 * // blocking for 10 seconds
 *
 * // process 2
 * $redis->lPush('key1', 'A');
 *
 * // process 1
 * // array('key1', 'A') is returned
 * </pre>
 */
 public function blPop($keys, $timeout) {}

/**
 * Is a blocking rPop primitive. If at least one of the lists contains at least one element,
 * the element will be popped from the head of the list and returned to the caller.
 * Il all the list identified by the keys passed in arguments are empty, brPop will
 * block during the specified timeout until an element is pushed to one of those lists. T
 * his element will be popped.
 *
 * @param string|string[] $keys String array containing the keys of the lists OR variadic list of strings
 * @param int $timeout Timeout is always the required final parameter
 *
 * @return array|Redis ['listName', 'element'] or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/brpop
 * @example
 * <pre>
 * // Non blocking feature
 * $redis->lPush('key1', 'A');
 * $redis->del('key2');
 *
 * $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
 * // OR
 * $redis->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
 *
 * $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
 * // OR
 * $redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
 *
 * // Blocking feature
 *
 * // process 1
 * $redis->del('key1');
 * $redis->blPop('key1', 10);
 * // blocking for 10 seconds
 *
 * // process 2
 * $redis->lPush('key1', 'A');
 *
 * // process 1
 * // array('key1', 'A') is returned
 * </pre>
 */
 public function brPop(array $keys, $timeout) {}

/**
 * Returns the size of a list identified by Key. If the list didn't exist or is empty,
 * the command returns 0. If the data type identified by Key is not a list, the command return FALSE.
 *
 * @param string $key
 *
 * @return int|bool|Redis The size of the list identified by Key exists or Redis if in multi mode
 * bool FALSE if the data type identified by Key is not list
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/llen
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
 * $redis->lLen('key1'); // 3
 * $redis->rPop('key1');
 * $redis->lLen('key1'); // 2
 * </pre>
 */
 public function lLen($key) {}

/**
     * @link https://redis.io/commands/llen
     *
     * @param string $key
     *
     * @return int|Redis The size of the list identified by Key exists or Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->lLen(%parametersList%)')]
    public function lSize($key) {}

/**
 * Return the specified element of the list stored at the specified key.
 * 0 the first element, 1 the second ... -1 the last element, -2 the penultimate ...
 * Return FALSE in case of a bad index or a key that doesn't point to a list.
 *
 * @param string $key
 * @param int $index
 *
 * @return mixed|bool|Redis the element at this index or Redis if in multi mode
 *
 * @throws RedisException
 *
 * Bool FALSE if the key identifies a non-string data type, or no value corresponds to this index in the list Key.
 *
 * @link https://redis.io/commands/lindex
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
 * $redis->lIndex('key1', 0); // 'A'
 * $redis->lIndex('key1', -1); // 'C'
 * $redis->lIndex('key1', 10); // `FALSE`
 * </pre>
 */
 public function lIndex($key, $index) {}

/**
     * @link https://redis.io/commands/lindex
     *
     * @param string $key
     * @param int $index
     * @return mixed|bool|Redis the element at this index or Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->lIndex(%parametersList%)')]
    public function lGet($key, $index) {}

/**
 * Set the list at index with the new value.
 *
 * @param string $key
 * @param int $index
 * @param string $value
 *
 * @return bool|Redis TRUE if the new value is setted or Redis if in multi mode
 * FALSE if the index is out of range, or data type identified by key is not a list.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lset
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
 * $redis->lIndex('key1', 0); // 'A'
 * $redis->lSet('key1', 0, 'X');
 * $redis->lIndex('key1', 0); // 'X'
 * </pre>
 */
 public function lSet($key, $index, $value) {}

/**
 * Returns the specified elements of the list stored at the specified key in
 * the range [start, end]. start and stop are interpretated as indices: 0 the first element,
 * 1 the second ... -1 the last element, -2 the penultimate ...
 *
 * @param string $key
 * @param int $start
 * @param int $end
 *
 * @return array|Redis containing the values in specified range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lrange
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C');
 * $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
 * </pre>
 */
 public function lRange($key, $start, $end) {}

/**
     * @link https://redis.io/commands/lrange
     *
     * @param string    $key
     * @param int       $start
     * @param int       $end
     * @return array|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->lRange(%parametersList%)')]
    public function lGetRange($key, $start, $end) {}

/**
 * Trims an existing list so that it will contain only a specified range of elements.
 *
 * @param string $key
 * @param int $start
 * @param int $stop
 *
 * @return array|false|Redis Bool return FALSE if the key identify a non-list value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/ltrim
 * @example
 * <pre>
 * $redis->rPush('key1', 'A');
 * $redis->rPush('key1', 'B');
 * $redis->rPush('key1', 'C');
 * $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
 * $redis->lTrim('key1', 0, 1);
 * $redis->lRange('key1', 0, -1); // array('A', 'B')
 * </pre>
 */
 public function lTrim($key, $start, $stop) {}

/**
     * @link  https://redis.io/commands/ltrim
     *
     * @param string    $key
     * @param int       $start
     * @param int       $stop
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->lTrim(%parametersList%)')]
    public function listTrim($key, $start, $stop) {}

/**
 * Removes the first count occurrences of the value element from the list.
 * If count is zero, all the matching elements are removed. If count is negative,
 * elements are removed from tail to head.
 *
 * @param string $key
 * @param string $value
 * @param int $count
 *
 * @return int|bool|Redis the number of elements to remove or Redis if in multi mode
 * bool FALSE if the value identified by key is not a list.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/lrem
 * @example
 * <pre>
 * $redis->lPush('key1', 'A');
 * $redis->lPush('key1', 'B');
 * $redis->lPush('key1', 'C');
 * $redis->lPush('key1', 'A');
 * $redis->lPush('key1', 'A');
 *
 * $redis->lRange('key1', 0, -1); // array('A', 'A', 'C', 'B', 'A')
 * $redis->lRem('key1', 'A', 2); // 2
 * $redis->lRange('key1', 0, -1); // array('C', 'B', 'A')
 * </pre>
 */
 public function lRem($key, $value, $count) {}

/**
     * @link https://redis.io/commands/lremove
     *
     * @param string $key
     * @param string $value
     * @param int $count
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->lRem(%parametersList%)')]
    public function lRemove($key, $value, $count) {}

/**
 * Insert value in the list before or after the pivot value. the parameter options
 * specify the position of the insert (before or after). If the list didn't exists,
 * or the pivot didn't exists, the value is not inserted.
 *
 * @param string $key
 * @param int $position Redis::BEFORE | Redis::AFTER
 * @param string $pivot
 * @param string|mixed $value
 *
 * @return int|Redis The number of the elements in the list, -1 if the pivot didn't exists or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/linsert
 * @example
 * <pre>
 * $redis->del('key1');
 * $redis->lInsert('key1', Redis::AFTER, 'A', 'X'); // 0
 *
 * $redis->lPush('key1', 'A');
 * $redis->lPush('key1', 'B');
 * $redis->lPush('key1', 'C');
 *
 * $redis->lInsert('key1', Redis::BEFORE, 'C', 'X'); // 4
 * $redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C')
 *
 * $redis->lInsert('key1', Redis::AFTER, 'C', 'Y'); // 5
 * $redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C', 'Y')
 *
 * $redis->lInsert('key1', Redis::AFTER, 'W', 'value'); // -1
 * </pre>
 */
 public function lInsert($key, $position, $pivot, $value) {}

/**
 * Adds a values to the set value stored at key.
 *
 * @param string $key Required key
 * @param string|mixed ...$value1 Variadic list of values
 *
 * @return int|bool|Redis The number of elements added to the set or Redis if in multi mode
 * If this value is already in the set, FALSE is returned
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sadd
 * @example
 * <pre>
 * $redis->sAdd('k', 'v1'); // int(1)
 * $redis->sAdd('k', 'v1', 'v2', 'v3'); // int(2)
 * </pre>
 */
 public function sAdd($key, ...$value1) {}

/**
 * Removes the specified members from the set value stored at key.
 *
 * @param string $key
 * @param string|mixed ...$member1 Variadic list of members
 *
 * @return int|Redis The number of elements removed from the set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/srem
 * @example
 * <pre>
 * var_dump( $redis->sAdd('k', 'v1', 'v2', 'v3') ); // int(3)
 * var_dump( $redis->sRem('k', 'v2', 'v3') ); // int(2)
 * var_dump( $redis->sMembers('k') );
 * //// Output:
 * // array(1) {
 * // [0]=> string(2) "v1"
 * // }
 * </pre>
 */
 public function sRem($key, ...$member1) {}

/**
     * @link    https://redis.io/commands/srem
     *
     * @param   string  $key
     * @param   string|mixed  ...$member1
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->sRem(%parametersList%)')]
    public function sRemove($key, ...$member1) {}

/**
 * Moves the specified member from the set at srcKey to the set at dstKey.
 *
 * @param string $srcKey
 * @param string $dstKey
 * @param string|mixed $member
 *
 * @return bool|Redis If the operation is successful, return TRUE or Redis if in multi mode
 * If the srcKey and/or dstKey didn't exist, and/or the member didn't exist in srcKey, FALSE is returned.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/smove
 * @example
 * <pre>
 * $redis->sAdd('key1' , 'set11');
 * $redis->sAdd('key1' , 'set12');
 * $redis->sAdd('key1' , 'set13'); // 'key1' => {'set11', 'set12', 'set13'}
 * $redis->sAdd('key2' , 'set21');
 * $redis->sAdd('key2' , 'set22'); // 'key2' => {'set21', 'set22'}
 * $redis->sMove('key1', 'key2', 'set13'); // 'key1' => {'set11', 'set12'}
 * // 'key2' => {'set21', 'set22', 'set13'}
 * </pre>
 */
 public function sMove($srcKey, $dstKey, $member) {}

/**
 * Checks if value is a member of the set stored at the key key.
 *
 * @param string $key
 * @param string|mixed $value
 *
 * @return bool|Redis TRUE if value is a member of the set at key key, FALSE otherwise or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sismember
 * @example
 * <pre>
 * $redis->sAdd('key1' , 'set1');
 * $redis->sAdd('key1' , 'set2');
 * $redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
 *
 * $redis->sIsMember('key1', 'set1'); // TRUE
 * $redis->sIsMember('key1', 'setX'); // FALSE
 * </pre>
 */
 public function sIsMember($key, $value) {}

/**
     * @link    https://redis.io/commands/sismember
     *
     * @param string       $key
     * @param string|mixed $value
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->sIsMember(%parametersList%)')]
    public function sContains($key, $value) {}

/**
 * Returns the cardinality of the set identified by key.
 *
 * @param string $key
 *
 * @return int|Redis the cardinality of the set identified by key, 0 if the set doesn't exist or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/scard
 * @example
 * <pre>
 * $redis->sAdd('key1' , 'set1');
 * $redis->sAdd('key1' , 'set2');
 * $redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
 * $redis->sCard('key1'); // 3
 * $redis->sCard('keyX'); // 0
 * </pre>
 */
 public function sCard($key) {}

/**
 * Removes and returns a random element from the set value at Key.
 *
 * @param string $key
 * @param int $count [optional]
 *
 * @return string|mixed|array|bool|Redis "popped" values or Redis if in multi mode
 * bool FALSE if set identified by key is empty or doesn't exist.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/spop
 * @example
 * <pre>
 * $redis->sAdd('key1' , 'set1');
 * $redis->sAdd('key1' , 'set2');
 * $redis->sAdd('key1' , 'set3'); // 'key1' => {'set3', 'set1', 'set2'}
 * $redis->sPop('key1'); // 'set1', 'key1' => {'set3', 'set2'}
 * $redis->sPop('key1'); // 'set3', 'key1' => {'set2'}
 *
 * // With count
 * $redis->sAdd('key2', 'set1', 'set2', 'set3');
 * var_dump( $redis->sPop('key2', 3) ); // Will return all members but in no particular order
 *
 * // array(3) {
 * // [0]=> string(4) "set2"
 * // [1]=> string(4) "set3"
 * // [2]=> string(4) "set1"
 * // }
 * </pre>
 */
 public function sPop($key, $count = 1) {}

/**
 * Returns a random element(s) from the set value at Key, without removing it.
 *
 * @param string $key
 * @param int $count [optional]
 *
 * @return string|mixed|array|bool|Redis value(s) from the set or Redis if in multi mode
 * bool FALSE if set identified by key is empty or doesn't exist and count argument isn't passed.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/srandmember
 * @example
 * <pre>
 * $redis->sAdd('key1' , 'one');
 * $redis->sAdd('key1' , 'two');
 * $redis->sAdd('key1' , 'three'); // 'key1' => {'one', 'two', 'three'}
 *
 * var_dump( $redis->sRandMember('key1') ); // 'key1' => {'one', 'two', 'three'}
 *
 * // string(5) "three"
 *
 * var_dump( $redis->sRandMember('key1', 2) ); // 'key1' => {'one', 'two', 'three'}
 *
 * // array(2) {
 * // [0]=> string(2) "one"
 * // [1]=> string(5) "three"
 * // }
 * </pre>
 */
 public function sRandMember($key, $count = 1) {}

/**
 * Returns the members of a set resulting from the intersection of all the sets
 * held at the specified keys. If just a single key is specified, then this command
 * produces the members of this set. If one of the keys is missing, FALSE is returned.
 *
 * @param string $key1 keys identifying the different sets on which we will apply the intersection.
 * @param string ...$otherKeys variadic list of keys
 *
 * @return array|false|Redis contain the result of the intersection between those keys or Redis if in multi mode
 * If the intersection between the different sets is empty, the return value will be empty array.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sinter
 * @example
 * <pre>
 * $redis->sAdd('key1', 'val1');
 * $redis->sAdd('key1', 'val2');
 * $redis->sAdd('key1', 'val3');
 * $redis->sAdd('key1', 'val4');
 *
 * $redis->sAdd('key2', 'val3');
 * $redis->sAdd('key2', 'val4');
 *
 * $redis->sAdd('key3', 'val3');
 * $redis->sAdd('key3', 'val4');
 *
 * var_dump($redis->sInter('key1', 'key2', 'key3'));
 *
 * //array(2) {
 * // [0]=>
 * // string(4) "val4"
 * // [1]=>
 * // string(4) "val3"
 * //}
 * </pre>
 */
 public function sInter($key1, ...$otherKeys) {}

/**
 * Performs a sInter command and stores the result in a new set.
 *
 * @param string $dstKey the key to store the diff into.
 * @param string $key1 keys identifying the different sets on which we will apply the intersection.
 * @param string ...$otherKeys variadic list of keys
 *
 * @return int|false|Redis The cardinality of the resulting set, or FALSE in case of a missing key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sinterstore
 * @example
 * <pre>
 * $redis->sAdd('key1', 'val1');
 * $redis->sAdd('key1', 'val2');
 * $redis->sAdd('key1', 'val3');
 * $redis->sAdd('key1', 'val4');
 *
 * $redis->sAdd('key2', 'val3');
 * $redis->sAdd('key2', 'val4');
 *
 * $redis->sAdd('key3', 'val3');
 * $redis->sAdd('key3', 'val4');
 *
 * var_dump($redis->sInterStore('output', 'key1', 'key2', 'key3'));
 * var_dump($redis->sMembers('output'));
 *
 * //int(2)
 * //
 * //array(2) {
 * // [0]=>
 * // string(4) "val4"
 * // [1]=>
 * // string(4) "val3"
 * //}
 * </pre>
 */
 public function sInterStore($dstKey, $key1, ...$otherKeys) {}

/**
 * Performs the union between N sets and returns it.
 *
 * @param string $key1 first key for union
 * @param string ...$otherKeys variadic list of keys corresponding to sets in redis
 *
 * @return array|Redis string[] The union of all these sets or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sunionstore
 * @example
 * <pre>
 * $redis->sAdd('s0', '1');
 * $redis->sAdd('s0', '2');
 * $redis->sAdd('s1', '3');
 * $redis->sAdd('s1', '1');
 * $redis->sAdd('s2', '3');
 * $redis->sAdd('s2', '4');
 *
 * var_dump($redis->sUnion('s0', 's1', 's2'));
 *
 * array(4) {
 * // [0]=>
 * // string(1) "3"
 * // [1]=>
 * // string(1) "4"
 * // [2]=>
 * // string(1) "1"
 * // [3]=>
 * // string(1) "2"
 * //}
 * </pre>
 */
 public function sUnion($key1, ...$otherKeys) {}

/**
 * Performs the same action as sUnion, but stores the result in the first key
 *
 * @param string $dstKey the key to store the diff into.
 * @param string $key1 first key for union
 * @param string ...$otherKeys variadic list of keys corresponding to sets in redis
 *
 * @return int|Redis Any number of keys corresponding to sets in redis or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sunionstore
 * @example
 * <pre>
 * $redis->del('s0', 's1', 's2');
 *
 * $redis->sAdd('s0', '1');
 * $redis->sAdd('s0', '2');
 * $redis->sAdd('s1', '3');
 * $redis->sAdd('s1', '1');
 * $redis->sAdd('s2', '3');
 * $redis->sAdd('s2', '4');
 *
 * var_dump($redis->sUnionStore('dst', 's0', 's1', 's2'));
 * var_dump($redis->sMembers('dst'));
 *
 * //int(4)
 * //array(4) {
 * // [0]=>
 * // string(1) "3"
 * // [1]=>
 * // string(1) "4"
 * // [2]=>
 * // string(1) "1"
 * // [3]=>
 * // string(1) "2"
 * //}
 * </pre>
 */
 public function sUnionStore($dstKey, $key1, ...$otherKeys) {}

/**
 * Performs the difference between N sets and returns it.
 *
 * @param string $key1 first key for diff
 * @param string ...$otherKeys variadic list of keys corresponding to sets in redis
 *
 * @return array|Redis string[] The difference of the first set will all the others or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sdiff
 * @example
 * <pre>
 * $redis->del('s0', 's1', 's2');
 *
 * $redis->sAdd('s0', '1');
 * $redis->sAdd('s0', '2');
 * $redis->sAdd('s0', '3');
 * $redis->sAdd('s0', '4');
 *
 * $redis->sAdd('s1', '1');
 * $redis->sAdd('s2', '3');
 *
 * var_dump($redis->sDiff('s0', 's1', 's2'));
 *
 * //array(2) {
 * // [0]=>
 * // string(1) "4"
 * // [1]=>
 * // string(1) "2"
 * //}
 * </pre>
 */
 public function sDiff($key1, ...$otherKeys) {}

/**
 * Performs the same action as sDiff, but stores the result in the first key
 *
 * @param string $dstKey the key to store the diff into.
 * @param string $key1 first key for diff
 * @param string ...$otherKeys variadic list of keys corresponding to sets in redis
 *
 * @return int|false|Redis The cardinality of the resulting set, or FALSE in case of a missing key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sdiffstore
 * @example
 * <pre>
 * $redis->del('s0', 's1', 's2');
 *
 * $redis->sAdd('s0', '1');
 * $redis->sAdd('s0', '2');
 * $redis->sAdd('s0', '3');
 * $redis->sAdd('s0', '4');
 *
 * $redis->sAdd('s1', '1');
 * $redis->sAdd('s2', '3');
 *
 * var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
 * var_dump($redis->sMembers('dst'));
 *
 * //int(2)
 * //array(2) {
 * // [0]=>
 * // string(1) "4"
 * // [1]=>
 * // string(1) "2"
 * //}
 * </pre>
 */
 public function sDiffStore($dstKey, $key1, ...$otherKeys) {}

/**
 * Returns the contents of a set.
 *
 * @param string $key
 *
 * @return array|Redis An array of elements, the contents of the set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/smembers
 * @example
 * <pre>
 * $redis->del('s');
 * $redis->sAdd('s', 'a');
 * $redis->sAdd('s', 'b');
 * $redis->sAdd('s', 'a');
 * $redis->sAdd('s', 'c');
 * var_dump($redis->sMembers('s'));
 *
 * //array(3) {
 * // [0]=>
 * // string(1) "c"
 * // [1]=>
 * // string(1) "a"
 * // [2]=>
 * // string(1) "b"
 * //}
 * // The order is random and corresponds to redis' own internal representation of the set structure.
 * </pre>
 */
 public function sMembers($key) {}

/**
     * @link    https://redis.io/commands/smembers
     *
     * @param  string  $key
     * @return array|Redis   An array of elements, the contents of the set or Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->sMembers(%parametersList%)')]
    public function sGetMembers($key) {}

/**
 * Scan a set for members
 *
 * @param string $key The set to search.
 * @param int &$iterator LONG (reference) to the iterator as we go.
 * @param string $pattern String, optional pattern to match against.
 * @param int $count How many members to return at a time (Redis might return a different amount)
 *
 * @return array|false|Redis PHPRedis will return an array of keys or FALSE when we're done iterating or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sscan
 * @example
 * <pre>
 * $iterator = null;
 * while ($members = $redis->sScan('set', $iterator)) {
 * foreach ($members as $member) {
 * echo $member . PHP_EOL;
 * }
 * }
 * </pre>
 */
 public function sScan($key, &$iterator, $pattern = null, $count = 0) {}

/**
 * Sets a value and returns the previous entry at that key.
 *
 * @param string $key
 * @param string|mixed $value
 *
 * @return string|mixed|Redis A string (mixed, if used serializer), the previous value located at this key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/getset
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
 * $newValue = $redis->get('x')' // return 'lol'
 * </pre>
 */
 public function getSet($key, $value) {}

/**
 * Returns a random key
 *
 * @return string|Redis an existing key in redis or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/randomkey
 * @example
 * <pre>
 * $key = $redis->randomKey();
 * $surprise = $redis->get($key); // who knows what's in there.
 * </pre>
 */
 public function randomKey() {}

/**
 * Switches to a given database
 *
 * @param int $dbIndex
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/select
 * @example
 * <pre>
 * $redis->select(0); // switch to DB 0
 * $redis->set('x', '42'); // write 42 to x
 * $redis->move('x', 1); // move to DB 1
 * $redis->select(1); // switch to DB 1
 * $redis->get('x'); // will return 42
 * </pre>
 */
 public function select($dbIndex) {}

/**
 * Moves a key to a different database.
 *
 * @param string $key
 * @param int $dbIndex
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/move
 * @example
 * <pre>
 * $redis->select(0); // switch to DB 0
 * $redis->set('x', '42'); // write 42 to x
 * $redis->move('x', 1); // move to DB 1
 * $redis->select(1); // switch to DB 1
 * $redis->get('x'); // will return 42
 * </pre>
 */
 public function move($key, $dbIndex) {}

/**
 * Renames a key
 *
 * @param string $srcKey
 * @param string $dstKey
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/rename
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $redis->rename('x', 'y');
 * $redis->get('y'); // → 42
 * $redis->get('x'); // → `FALSE`
 * </pre>
 */
 public function rename($srcKey, $dstKey) {}

/**
     * @link    https://redis.io/commands/rename
     *
     * @param   string  $srcKey
     * @param   string  $dstKey
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->rename(%parametersList%)')]
    public function renameKey($srcKey, $dstKey) {}

/**
 * Renames a key
 *
 * Same as rename, but will not replace a key if the destination already exists.
 * This is the same behaviour as setnx.
 *
 * @param string $srcKey
 * @param string $dstKey
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/renamenx
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $redis->rename('x', 'y');
 * $redis->get('y'); // → 42
 * $redis->get('x'); // → `FALSE`
 * </pre>
 */
 public function renameNx($srcKey, $dstKey) {}

/**
 * Sets an expiration date (a timeout) on an item
 *
 * @param string $key The key that will disappear
 * @param int $ttl The key's remaining Time To Live, in seconds
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/expire
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $redis->expire('x', 3); // x will disappear in 3 seconds.
 * sleep(5); // wait 5 seconds
 * $redis->get('x'); // will return `FALSE`, as 'x' has expired.
 * </pre>
 */
 public function expire($key, $ttl) {}

/**
 * Sets an expiration date (a timeout in milliseconds) on an item
 *
 * @param string $key The key that will disappear.
 * @param int $ttl The key's remaining Time To Live, in milliseconds
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pexpire
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $redis->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
 * $redis->ttl('x'); // 12
 * $redis->pttl('x'); // 11500
 * </pre>
 */
 public function pExpire($key, $ttl) {}

/**
     * @link    https://redis.io/commands/expire
     *
     * @param   string  $key
     * @param   int     $ttl
     * @return  bool|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->expire(%parametersList%)')]
    public function setTimeout($key, $ttl) {}

/**
 * Sets an expiration date (a timestamp) on an item.
 *
 * @param string $key The key that will disappear.
 * @param int $timestamp Unix timestamp. The key's date of death, in seconds from Epoch time.
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/expireat
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $now = time(NULL); // current timestamp
 * $redis->expireAt('x', $now + 3); // x will disappear in 3 seconds.
 * sleep(5); // wait 5 seconds
 * $redis->get('x'); // will return `FALSE`, as 'x' has expired.
 * </pre>
 */
 public function expireAt($key, $timestamp) {}

/**
 * Sets an expiration date (a timestamp) on an item. Requires a timestamp in milliseconds
 *
 * @param string $key The key that will disappear
 * @param int $timestamp Unix timestamp. The key's date of death, in seconds from Epoch time
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pexpireat
 * @example
 * <pre>
 * $redis->set('x', '42');
 * $redis->pExpireAt('x', 1555555555005);
 * echo $redis->ttl('x'); // 218270121
 * echo $redis->pttl('x'); // 218270120575
 * </pre>
 */
 public function pExpireAt($key, $timestamp) {}

/**
 * Returns the keys that match a certain pattern.
 *
 * @param string $pattern pattern, using '*' as a wildcard
 *
 * @return array|Redis string[] The keys that match a certain pattern or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/keys
 * @example
 * <pre>
 * $allKeys = $redis->keys('*'); // all keys will match this.
 * $keyWithUserPrefix = $redis->keys('user*');
 * </pre>
 */
 public function keys($pattern) {}

/**
     * @param string $pattern
     *
     * @throws RedisException
     * @link    https://redis.io/commands/keys
     */
    #[Deprecated(replacement: '%class%->keys(%parametersList%)')]
    public function getKeys($pattern) {}

/**
 * Returns the current database's size
 *
 * @return int|Redis DB size, in number of keys or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/dbsize
 * @example
 * <pre>
 * $count = $redis->dbSize();
 * echo "Redis has $count keys\n";
 * </pre>
 */
 public function dbSize() {}

/**
     * Authenticate the connection using a password.
     * Warning: The password is sent in plain-text over the network.
     *
     * @param string|string[] $password
     *
     * @return bool|Redis TRUE if the connection is authenticated, FALSE otherwise or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/auth
     * @example $redis->auth('foobared');
     */
    public function auth($password) {}

/**
     * Starts the background rewrite of AOF (Append-Only File)
     *
     * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/bgrewriteaof
     * @example $redis->bgrewriteaof();
     */
    public function bgrewriteaof() {}

/**
 * Changes the slave status
 * Either host and port, or no parameter to stop being a slave.
 *
 * @param string $host [optional]
 * @param int $port [optional]
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/slaveof
 * @example
 * <pre>
 * $redis->slaveof('10.0.1.7', 6379);
 * // ...
 * $redis->slaveof();
 * </pre>
 */
 public function slaveof($host = '127.0.0.1', $port = 6379) {}

/**
 * Access the Redis slowLog
 *
 * @param string $operation This can be either GET, LEN, or RESET
 * @param int|null $length If executing a SLOWLOG GET command, you can pass an optional length.
 *
 * @return mixed|Redis The return value of SLOWLOG will depend on which operation was performed or Redis if in multi mode
 * - SLOWLOG GET: Array of slowLog entries, as provided by Redis
 * - SLOGLOG LEN: Integer, the length of the slowLog
 * - SLOWLOG RESET: Boolean, depending on success
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * // Get ten slowLog entries
 * $redis->slowLog('get', 10);
 * // Get the default number of slowLog entries
 *
 * $redis->slowLog('get');
 * // Reset our slowLog
 * $redis->slowLog('reset');
 *
 * // Retrieve slowLog length
 * $redis->slowLog('len');
 * </pre>
 *
 * @link https://redis.io/commands/slowlog
 */
 public function slowLog(string $operation, int $length = null) {}

/**
 * Describes the object pointed to by a key.
 * The information to retrieve (string) and the key (string).
 * Info can be one of the following:
 * - "encoding"
 * - "refcount"
 * - "idletime"
 *
 * @param string $string
 * @param string $key
 *
 * @return string|int|false|Redis for "encoding", int for "refcount" and "idletime", FALSE if the key doesn't exist or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/object
 * @example
 * <pre>
 * $redis->lPush('l', 'Hello, world!');
 * $redis->object("encoding", "l"); // → ziplist
 * $redis->object("refcount", "l"); // → 1
 * $redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
 * </pre>
 */
 public function object($string = '', $key = '') {}

/**
     * Performs a synchronous save.
     *
     * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
     * If a save is already running, this command will fail and return FALSE.
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/save
     * @example $redis->save();
     */
    public function save() {}

/**
     * Performs a background save.
     *
     * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
     * If a save is already running, this command will fail and return FALSE
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/bgsave
     * @example $redis->bgSave();
     */
    public function bgsave() {}

/**
     * Returns the timestamp of the last disk save.
     *
     * @return int|Redis timestamp or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/lastsave
     * @example $redis->lastSave();
     */
    public function lastSave() {}

/**
     * Blocks the current client until all the previous write commands are successfully transferred and
     * acknowledged by at least the specified number of slaves.
     *
     * @param int $numSlaves Number of slaves that need to acknowledge previous write commands.
     * @param int $timeout   Timeout in milliseconds.
     *
     * @return  int|Redis The command returns the number of slaves reached by all the writes performed in the or Redis if in multi mode
     *              context of the current connection
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/wait
     * @example $redis->wait(2, 1000);
     */
    public function wait($numSlaves, $timeout) {}

/**
     * Returns the type of data pointed by a given key.
     *
     * @param string $key
     *
     * @return int|Redis returns Redis if in multi mode
     * Depending on the type of the data pointed by the key,
     * this method will return the following value:
     * - string: Redis::REDIS_STRING
     * - set:   Redis::REDIS_SET
     * - list:  Redis::REDIS_LIST
     * - zset:  Redis::REDIS_ZSET
     * - hash:  Redis::REDIS_HASH
     * - other: Redis::REDIS_NOT_FOUND
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/type
     * @example $redis->type('key');
     */
    public function type($key) {}

/**
 * Append specified string to the string stored in specified key.
 *
 * @param string $key
 * @param string|mixed $value
 *
 * @return int|Redis Size of the value after the append or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/append
 * @example
 * <pre>
 * $redis->set('key', 'value1');
 * $redis->append('key', 'value2'); // 12
 * $redis->get('key'); // 'value1value2'
 * </pre>
 */
 public function append($key, $value) {}

/**
 * Return a substring of a larger string
 *
 * @param string $key
 * @param int $start
 * @param int $end
 *
 * @return string|Redis the substring or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/getrange
 * @example
 * <pre>
 * $redis->set('key', 'string value');
 * $redis->getRange('key', 0, 5); // 'string'
 * $redis->getRange('key', -5, -1); // 'value'
 * </pre>
 */
 public function getRange($key, $start, $end) {}

/**
     * Return a substring of a larger string
     *
     * @param   string  $key
     * @param   int     $start
     * @param   int     $end
     *
     * @throws RedisException
     */
    #[Deprecated]
    public function substr($key, $start, $end) {}

/**
 * Changes a substring of a larger string.
 *
 * @param string $key
 * @param int $offset
 * @param string $value
 *
 * @return int|Redis the length of the string after it was modified or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/setrange
 * @example
 * <pre>
 * $redis->set('key', 'Hello world');
 * $redis->setRange('key', 6, "redis"); // returns 11
 * $redis->get('key'); // "Hello redis"
 * </pre>
 */
 public function setRange($key, $offset, $value) {}

/**
 * Get the length of a string value.
 *
 * @param string $key
 * @return int|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/strlen
 * @example
 * <pre>
 * $redis->set('key', 'value');
 * $redis->strlen('key'); // 5
 * </pre>
 */
 public function strlen($key) {}

/**
 * Return the position of the first bit set to 1 or 0 in a string. The position is returned, thinking of the
 * string as an array of bits from left to right, where the first byte's most significant bit is at position 0,
 * the second byte's most significant bit is at position 8, and so forth.
 *
 * @param string $key
 * @param int $bit
 * @param int $start
 * @param int $end
 *
 * @return int|Redis The command returns the position of the first bit set to 1 or 0 according to the request or Redis if in multi mode
 * If we look for set bits (the bit argument is 1) and the string is empty or composed of just
 * zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string
 * only contains bit set to 1, the function returns the first bit not part of the string on the
 * right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will
 * return 24, since up to bit 23 all the bits are 1. Basically, the function considers the right
 * of the string as padded with zeros if you look for clear bits and specify no range or the
 * start argument only. However, this behavior changes if you are looking for clear bits and
 * specify a range with both start and end. If no clear bit is found in the specified range, the
 * function returns -1 as the user specified a clear range and there are no 0 bits in that range.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/bitpos
 * @example
 * <pre>
 * $redis->set('key', '\xff\xff');
 * $redis->bitpos('key', 1); // int(0)
 * $redis->bitpos('key', 1, 1); // int(8)
 * $redis->bitpos('key', 1, 3); // int(-1)
 * $redis->bitpos('key', 0); // int(16)
 * $redis->bitpos('key', 0, 1); // int(16)
 * $redis->bitpos('key', 0, 1, 5); // int(-1)
 * </pre>
 */
 public function bitpos($key, $bit, $start = 0, $end = null) {}

/**
 * Return a single bit out of a larger string
 *
 * @param string $key
 * @param int $offset
 *
 * @return int|Redis the bit value (0 or 1) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/getbit
 * @example
 * <pre>
 * $redis->set('key', "\x7f"); // this is 0111 1111
 * $redis->getBit('key', 0); // 0
 * $redis->getBit('key', 1); // 1
 * </pre>
 */
 public function getBit($key, $offset) {}

/**
 * Changes a single bit of a string.
 *
 * @param string $key
 * @param int $offset
 * @param bool|int $value bool or int (1 or 0)
 *
 * @return int|Redis 0 or 1, the value of the bit before it was set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/setbit
 * @example
 * <pre>
 * $redis->set('key', "*"); // ord("*") = 42 = 0x2f = "0010 1010"
 * $redis->setBit('key', 5, 1); // returns 0
 * $redis->setBit('key', 7, 1); // returns 0
 * $redis->get('key'); // chr(0x2f) = "/" = b("0010 1111")
 * </pre>
 */
 public function setBit($key, $offset, $value) {}

/**
 * Count bits in a string
 *
 * @param string $key
 *
 * @return int|Redis The number of bits set to 1 in the value behind the input key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/bitcount
 * @example
 * <pre>
 * $redis->set('bit', '345'); // // 11 0011 0011 0100 0011 0101
 * var_dump( $redis->bitCount('bit', 0, 0) ); // int(4)
 * var_dump( $redis->bitCount('bit', 1, 1) ); // int(3)
 * var_dump( $redis->bitCount('bit', 2, 2) ); // int(4)
 * var_dump( $redis->bitCount('bit', 0, 2) ); // int(11)
 * </pre>
 */
 public function bitCount($key) {}

/**
 * Bitwise operation on multiple keys.
 *
 * @param string $operation either "AND", "OR", "NOT", "XOR"
 * @param string $retKey return key
 * @param string $key1 first key
 * @param string ...$otherKeys variadic list of keys
 *
 * @return int|Redis The size of the string stored in the destination key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/bitop
 * @example
 * <pre>
 * $redis->set('bit1', '1'); // 11 0001
 * $redis->set('bit2', '2'); // 11 0010
 *
 * $redis->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
 * $redis->bitOp('OR', 'bit', 'bit1', 'bit2'); // bit = 110011
 * $redis->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
 * $redis->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
 * </pre>
 */
 public function bitOp($operation, $retKey, $key1, ...$otherKeys) {}

/**
     * Removes all entries from the current database.
     *
     * @return bool|Redis Always TRUE or Redis if in multi mode
     * @throws RedisException
     * @link    https://redis.io/commands/flushdb
     * @example $redis->flushDB();
     */
    public function flushDB() {}

/**
     * Removes all entries from all databases.
     *
     * @return bool|Redis Always TRUE or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/flushall
     * @example $redis->flushAll();
     */
    public function flushAll() {}

/**
 * Sort
 *
 * @param string $key
 * @param array $option array(key => value, ...) - optional, with the following keys and values:
 * - 'by' => 'some_pattern_*',
 * - 'limit' => array(0, 1),
 * - 'get' => 'some_other_pattern_*' or an array of patterns,
 * - 'sort' => 'asc' or 'desc',
 * - 'alpha' => TRUE,
 * - 'store' => 'external-key'
 *
 * @return array|Redis returns Redis if in multi mode
 * An array of values, or a number corresponding to the number of elements stored if that was used
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sort
 * @example
 * <pre>
 * $redis->del('s');
 * $redis->sadd('s', 5);
 * $redis->sadd('s', 4);
 * $redis->sadd('s', 2);
 * $redis->sadd('s', 1);
 * $redis->sadd('s', 3);
 *
 * var_dump($redis->sort('s')); // 1,2,3,4,5
 * var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
 * var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
 * </pre>
 */
 public function sort($key, $option = null) {}

/**
 * Returns an associative array of strings and integers
 *
 * @param string $option Optional. The option to provide redis.
 * SERVER | CLIENTS | MEMORY | PERSISTENCE | STATS | REPLICATION | CPU | CLASTER | KEYSPACE | COMANDSTATS
 *
 * Returns an associative array of strings and integers, with the following keys:
 * - redis_version
 * - redis_git_sha1
 * - redis_git_dirty
 * - arch_bits
 * - multiplexing_api
 * - process_id
 * - uptime_in_seconds
 * - uptime_in_days
 * - lru_clock
 * - used_cpu_sys
 * - used_cpu_user
 * - used_cpu_sys_children
 * - used_cpu_user_children
 * - connected_clients
 * - connected_slaves
 * - client_longest_output_list
 * - client_biggest_input_buf
 * - blocked_clients
 * - used_memory
 * - used_memory_human
 * - used_memory_peak
 * - used_memory_peak_human
 * - mem_fragmentation_ratio
 * - mem_allocator
 * - loading
 * - aof_enabled
 * - changes_since_last_save
 * - bgsave_in_progress
 * - last_save_time
 * - total_connections_received
 * - total_commands_processed
 * - expired_keys
 * - evicted_keys
 * - keyspace_hits
 * - keyspace_misses
 * - hash_max_zipmap_entries
 * - hash_max_zipmap_value
 * - pubsub_channels
 * - pubsub_patterns
 * - latest_fork_usec
 * - vm_enabled
 * - role
 *
 * @return array|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/info
 * @example
 * <pre>
 * $redis->info();
 *
 * or
 *
 * $redis->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
 * $redis->info("CPU"); // just CPU information from Redis INFO
 * </pre>
 */
 public function info($option = null) {}

/**
 * Returns an indexed array whose first element is the role
 *
 * @return array|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/role
 * @example
 * <pre>
 * $redis->role();
 * </pre>
 */
 public function role() {}

/**
     * Resets the statistics reported by Redis using the INFO command (`info()` function).
     * These are the counters that are reset:
     *      - Keyspace hits
     *      - Keyspace misses
     *      - Number of commands processed
     *      - Number of connections received
     *      - Number of expired keys
     *
     * @return bool|Redis `TRUE` in case of success, `FALSE` in case of failure or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @example $redis->resetStat();
     * @link https://redis.io/commands/config-resetstat
     */
    public function resetStat() {}

/**
 * Returns the time to live left for a given key, in seconds. If the key doesn't exist, FALSE is returned.
 *
 * @param string $key
 *
 * @return int|bool|Redis the time left to live in seconds or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/ttl
 * @example
 * <pre>
 * $redis->setEx('key', 123, 'test');
 * $redis->ttl('key'); // int(123)
 * </pre>
 */
 public function ttl($key) {}

/**
 * Returns a time to live left for a given key, in milliseconds.
 *
 * If the key doesn't exist, FALSE is returned.
 *
 * @param string $key
 *
 * @return int|bool|Redis the time left to live in milliseconds or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pttl
 * @example
 * <pre>
 * $redis->setEx('key', 123, 'test');
 * $redis->pttl('key'); // int(122999)
 * </pre>
 */
 public function pttl($key) {}

/**
     * Remove the expiration timer from a key.
     *
     * @param string $key
     *
     * @return bool|Redis TRUE if a timeout was removed, FALSE if the key didn’t exist or didn’t have an expiration timer or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/persist
     * @example $redis->persist('key');
     */
    public function persist($key) {}

/**
 * Sets multiple key-value pairs in one atomic command.
 * MSETNX only returns TRUE if all the keys were set (see SETNX).
 *
 * @param array $array Pairs: array(key => value, ...)
 *
 * @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/mset
 * @example
 * <pre>
 * $redis->mSet(array('key0' => 'value0', 'key1' => 'value1'));
 * var_dump($redis->get('key0'));
 * var_dump($redis->get('key1'));
 * // Output:
 * // string(6) "value0"
 * // string(6) "value1"
 * </pre>
 */
 public function mSet(array $array) {}

/**
 * Get the values of all the specified keys.
 * If one or more keys dont exist, the array will contain FALSE at the position of the key.
 *
 * @param array $keys Array containing the list of the keys
 *
 * @return array|Redis Array containing the values related to keys in argument or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->set('key1', 'value1');
 * $redis->set('key2', 'value2');
 * $redis->set('key3', 'value3');
 * $redis->getMultiple(array('key1', 'key2', 'key3')); // array('value1', 'value2', 'value3');
 * $redis->getMultiple(array('key0', 'key1', 'key5')); // array(`FALSE`, 'value2', `FALSE`);
 * </pre>
 */
 #[Deprecated(replacement: '%class%->mGet(%parametersList%)')]
 public function getMultiple(array $keys) {}

/**
 * Returns the values of all specified keys.
 *
 * For every key that does not hold a string value or does not exist,
 * the special value false is returned. Because of this, the operation never fails.
 *
 * @param array $array
 *
 * @return array|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/mget
 * @example
 * <pre>
 * $redis->del('x', 'y', 'z', 'h'); // remove x y z
 * $redis->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
 * $redis->hset('h', 'field', 'value');
 * var_dump($redis->mget(array('x', 'y', 'z', 'h')));
 * // Output:
 * // array(3) {
 * // [0]=> string(1) "a"
 * // [1]=> string(1) "b"
 * // [2]=> string(1) "c"
 * // [3]=> bool(false)
 * // }
 * </pre>
 */
 public function mGet(array $array) {}

/**
     * @see mset()
     * @param array $array
     * @return int|Redis 1 (if the keys were set) or 0 (no key was set) or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/msetnx
     */
    public function msetnx(array $array) {}

/**
 * Pops a value from the tail of a list, and pushes it to the front of another list.
 * Also return this value.
 *
 * @since redis >= 1.1
 *
 * @param string $srcKey
 * @param string $dstKey
 *
 * @return string|mixed|false|Redis The element that was moved in case of success, FALSE in case of failure or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/rpoplpush
 * @example
 * <pre>
 * $redis->del('x', 'y');
 *
 * $redis->lPush('x', 'abc');
 * $redis->lPush('x', 'def');
 * $redis->lPush('y', '123');
 * $redis->lPush('y', '456');
 *
 * // move the last of x to the front of y.
 * var_dump($redis->rpoplpush('x', 'y'));
 * var_dump($redis->lRange('x', 0, -1));
 * var_dump($redis->lRange('y', 0, -1));
 *
 * //Output:
 * //
 * //string(3) "abc"
 * //array(1) {
 * // [0]=>
 * // string(3) "def"
 * //}
 * //array(3) {
 * // [0]=>
 * // string(3) "abc"
 * // [1]=>
 * // string(3) "456"
 * // [2]=>
 * // string(3) "123"
 * //}
 * </pre>
 */
 public function rPopLPush($srcKey, $dstKey) {}

/**
     * A blocking version of rPopLPush, with an integral timeout in the third parameter.
     *
     * @param string $srcKey
     * @param string $dstKey
     * @param int    $timeout
     *
     * @return  string|mixed|bool|Redis  The element that was moved in case of success, FALSE in case of timeout or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/brpoplpush
     */
    public function bRPopLPush($srcKey, $dstKey, $timeout) {}

/**
 * Adds the specified member with a given score to the sorted set stored at key
 *
 * @param string $key Required key
 * @param array|float $options Options if needed or score if omitted
 * @param float|string|mixed $score1 Required score or value if options omitted
 * @param string|float|mixed $value1 Required value or optional score if options omitted
 * @param float|string|mixed $score2 Optional score or value if options omitted
 * @param string|float|mixed $value2 Optional value or score if options omitted
 * @param float|string|mixed $scoreN Optional score or value if options omitted
 * @param string|float|mixed $valueN Optional value or score if options omitted
 *
 * @return int|Redis Number of values added or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zadd
 * @example
 * <pre>
 * $redis->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
 * $redis->zRem('z', 'v2', 'v3'); // int(2)
 * $redis->zAdd('z', ['NX'], 5, 'v5'); // int(1)
 * $redis->zAdd('z', ['NX'], 6, 'v5'); // int(0)
 * $redis->zAdd('z', 7, 'v6'); // int(1)
 * $redis->zAdd('z', 8, 'v6'); // int(0)
 *
 * var_dump( $redis->zRange('z', 0, -1) );
 * // Output:
 * // array(4) {
 * // [0]=> string(2) "v1"
 * // [1]=> string(2) "v4"
 * // [2]=> string(2) "v5"
 * // [3]=> string(2) "v8"
 * // }
 *
 * var_dump( $redis->zRange('z', 0, -1, true) );
 * // Output:
 * // array(4) {
 * // ["v1"]=> float(1)
 * // ["v4"]=> float(4)
 * // ["v5"]=> float(5)
 * // ["v6"]=> float(8)
 * </pre>
 */
 public function zAdd($key, $options, $score1, $value1 = null, $score2 = null, $value2 = null, $scoreN = null, $valueN = null) {}

/**
 * Returns a range of elements from the ordered set stored at the specified key,
 * with values in the range [start, end]. start and stop are interpreted as zero-based indices:
 * 0 the first element,
 * 1 the second ...
 * -1 the last element,
 * -2 the penultimate ...
 *
 * @param string $key
 * @param int $start
 * @param int $end
 * @param bool $withscores
 *
 * @return array|Redis Array containing the values in specified range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrange
 * @example
 * <pre>
 * $redis->zAdd('key1', 0, 'val0');
 * $redis->zAdd('key1', 2, 'val2');
 * $redis->zAdd('key1', 10, 'val10');
 * $redis->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
 * // with scores
 * $redis->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
 * </pre>
 */
 public function zRange($key, $start, $end, $withscores = null) {}

/**
 * Deletes a specified member from the ordered set.
 *
 * @param string $key
 * @param string|mixed $member1
 * @param string|mixed ...$otherMembers
 *
 * @return int|Redis Number of deleted values or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrem
 * @example
 * <pre>
 * $redis->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
 * $redis->zRem('z', 'v2', 'v3'); // int(2)
 * var_dump( $redis->zRange('z', 0, -1) );
 * //// Output:
 * // array(2) {
 * // [0]=> string(2) "v1"
 * // [1]=> string(2) "v4"
 * // }
 * </pre>
 */
 public function zRem($key, $member1, ...$otherMembers) {}

/**
     * @link https://redis.io/commands/zrem
     *
     * @param string       $key
     * @param string|mixed $member1
     * @param string|mixed ...$otherMembers
     *
     * @return int|Redis Number of deleted values or Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zRem(%parametersList%)')]
    public function zDelete($key, $member1, ...$otherMembers) {}

/**
 * Returns the elements of the sorted set stored at the specified key in the range [start, end]
 * in reverse order. start and stop are interpretated as zero-based indices:
 * 0 the first element,
 * 1 the second ...
 * -1 the last element,
 * -2 the penultimate ...
 *
 * @param string $key
 * @param int $start
 * @param int $end
 * @param bool $withscore
 *
 * @return array|Redis Array containing the values in specified range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrevrange
 * @example
 * <pre>
 * $redis->zAdd('key', 0, 'val0');
 * $redis->zAdd('key', 2, 'val2');
 * $redis->zAdd('key', 10, 'val10');
 * $redis->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')
 *
 * // with scores
 * $redis->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
 * </pre>
 */
 public function zRevRange($key, $start, $end, $withscore = null) {}

/**
 * Returns the elements of the sorted set stored at the specified key which have scores in the
 * range [start,end]. Adding a parenthesis before start or end excludes it from the range.
 * +inf and -inf are also valid limits.
 *
 * zRevRangeByScore returns the same items in reverse order, when the start and end parameters are swapped.
 *
 * @param string $key
 * @param int $start
 * @param int $end
 * @param array $options Two options are available:
 * - withscores => TRUE,
 * - and limit => array($offset, $count)
 *
 * @return array|Redis Array containing the values in specified range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrangebyscore
 * @example
 * <pre>
 * $redis->zAdd('key', 0, 'val0');
 * $redis->zAdd('key', 2, 'val2');
 * $redis->zAdd('key', 10, 'val10');
 * $redis->zRangeByScore('key', 0, 3); // array('val0', 'val2')
 * $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE); // array('val0' => 0, 'val2' => 2)
 * $redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1)); // array('val2')
 * $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1)); // array('val2' => 2)
 * </pre>
 */
 public function zRangeByScore($key, $start, $end, array $options = []) {}

/**
     * @see zRangeByScore()
     * @param string $key
     * @param int    $start
     * @param int    $end
     * @param array  $options
     *
     * @return array|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     */
    public function zRevRangeByScore($key, $start, $end, array $options = []) {}

/**
 * Returns a lexigraphical range of members in a sorted set, assuming the members have the same score. The
 * min and max values are required to start with '(' (exclusive), '[' (inclusive), or be exactly the values
 * '-' (negative inf) or '+' (positive inf). The command must be called with either three *or* five
 * arguments or will return FALSE.
 *
 * @param string $key The ZSET you wish to run against.
 * @param int $min The minimum alphanumeric value you wish to get.
 * @param int $max The maximum alphanumeric value you wish to get.
 * @param int $offset Optional argument if you wish to start somewhere other than the first element.
 * @param int $limit Optional argument if you wish to limit the number of elements returned.
 *
 * @return array|false|Redis Array containing the values in the specified range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrangebylex
 * @example
 * <pre>
 * foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $char) {
 * $redis->zAdd('key', $char);
 * }
 *
 * $redis->zRangeByLex('key', '-', '[c'); // array('a', 'b', 'c')
 * $redis->zRangeByLex('key', '-', '(c'); // array('a', 'b')
 * $redis->zRangeByLex('key', '-', '[c'); // array('b', 'c')
 * </pre>
 */
 public function zRangeByLex($key, $min, $max, $offset = null, $limit = null) {}

/**
     * @see zRangeByLex()
     * @param string $key
     * @param int    $min
     * @param int    $max
     * @param int    $offset
     * @param int    $limit
     *
     * @return array|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/zrevrangebylex
     */
    public function zRevRangeByLex($key, $min, $max, $offset = null, $limit = null) {}

/**
 * Returns the number of elements of the sorted set stored at the specified key which have
 * scores in the range [start,end]. Adding a parenthesis before start or end excludes it
 * from the range. +inf and -inf are also valid limits.
 *
 * @param string $key
 * @param string $start
 * @param string $end
 *
 * @return int|Redis the size of a corresponding zRangeByScore or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zcount
 * @example
 * <pre>
 * $redis->zAdd('key', 0, 'val0');
 * $redis->zAdd('key', 2, 'val2');
 * $redis->zAdd('key', 10, 'val10');
 * $redis->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
 * </pre>
 */
 public function zCount($key, $start, $end) {}

/**
 * Deletes the elements of the sorted set stored at the specified key which have scores in the range [start,end].
 *
 * @param string $key
 * @param string $start double or "+inf" or "-inf" as a string
 * @param string $end double or "+inf" or "-inf" as a string
 *
 * @return int|Redis The number of values deleted from the sorted set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zremrangebyscore
 * @example
 * <pre>
 * $redis->zAdd('key', 0, 'val0');
 * $redis->zAdd('key', 2, 'val2');
 * $redis->zAdd('key', 10, 'val10');
 * $redis->zRemRangeByScore('key', '0', '3'); // 2
 * </pre>
 */
 public function zRemRangeByScore($key, $start, $end) {}

/**
     * @param string $key
     * @param float  $start
     * @param float  $end
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zRemRangeByScore(%parametersList%)')]
    public function zDeleteRangeByScore($key, $start, $end) {}

/**
 * Deletes the elements of the sorted set stored at the specified key which have rank in the range [start,end].
 *
 * @param string $key
 * @param int $start
 * @param int $end
 *
 * @return int|Redis The number of values deleted from the sorted set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zremrangebyrank
 * @example
 * <pre>
 * $redis->zAdd('key', 1, 'one');
 * $redis->zAdd('key', 2, 'two');
 * $redis->zAdd('key', 3, 'three');
 * $redis->zRemRangeByRank('key', 0, 1); // 2
 * $redis->zRange('key', 0, -1, array('withscores' => TRUE)); // array('three' => 3)
 * </pre>
 */
 public function zRemRangeByRank($key, $start, $end) {}

/**
     * @link    https://redis.io/commands/zremrangebyscore
     *
     * @param string $key
     * @param int    $start
     * @param int    $end
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zRemRangeByRank(%parametersList%)')]
    public function zDeleteRangeByRank($key, $start, $end) {}

/**
 * Returns the cardinality of an ordered set.
 *
 * @param string $key
 *
 * @return int|Redis the set's cardinality or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zsize
 * @example
 * <pre>
 * $redis->zAdd('key', 0, 'val0');
 * $redis->zAdd('key', 2, 'val2');
 * $redis->zAdd('key', 10, 'val10');
 * $redis->zCard('key'); // 3
 * </pre>
 */
 public function zCard($key) {}

/**
     * @param string $key
     * @return int|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zCard(%parametersList%)')]
    public function zSize($key) {}

/**
 * Returns the score of a given member in the specified sorted set.
 *
 * @param string $key
 * @param string|mixed $member
 *
 * @return float|bool|Redis false if member or key not exists or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zscore
 * @example
 * <pre>
 * $redis->zAdd('key', 2.5, 'val2');
 * $redis->zScore('key', 'val2'); // 2.5
 * </pre>
 */
 public function zScore($key, $member) {}

/**
 * Returns the rank of a given member in the specified sorted set, starting at 0 for the item
 * with the smallest score. zRevRank starts at 0 for the item with the largest score.
 *
 * @param string $key
 * @param string|mixed $member
 *
 * @return int|false|Redis the item's score, or false if key or member is not exists or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zrank
 * @example
 * <pre>
 * $redis->del('z');
 * $redis->zAdd('key', 1, 'one');
 * $redis->zAdd('key', 2, 'two');
 * $redis->zRank('key', 'one'); // 0
 * $redis->zRank('key', 'two'); // 1
 * $redis->zRevRank('key', 'one'); // 1
 * $redis->zRevRank('key', 'two'); // 0
 * </pre>
 */
 public function zRank($key, $member) {}

/**
     * @see zRank()
     * @param string       $key
     * @param string|mixed $member
     *
     * @return int|false|Redis the item's score, false - if key or member is not exists or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link   https://redis.io/commands/zrevrank
     */
    public function zRevRank($key, $member) {}

/**
 * Increments the score of a member from a sorted set by a given amount.
 *
 * @param string $key
 * @param float $value (double) value that will be added to the member's score
 * @param string $member
 *
 * @return float|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zincrby
 * @example
 * <pre>
 * $redis->del('key');
 * $redis->zIncrBy('key', 2.5, 'member1'); // key or member1 didn't exist, so member1's score is to 0
 * // before the increment and now has the value 2.5
 * $redis->zIncrBy('key', 1, 'member1'); // 3.5
 * </pre>
 */
 public function zIncrBy($key, $value, $member) {}

/**
 * Creates an union of sorted sets given in second argument.
 * The result of the union will be stored in the sorted set defined by the first argument.
 * The third optionnel argument defines weights to apply to the sorted sets in input.
 * In this case, the weights will be multiplied by the score of each element in the sorted set
 * before applying the aggregation. The forth argument defines the AGGREGATE option which
 * specify how the results of the union are aggregated.
 *
 * @param string $output
 * @param array $zSetKeys
 * @param null|array $weights
 * @param string $aggregateFunction Either "SUM", "MIN", or "MAX": defines the behaviour to use on
 * duplicate entries during the zUnionStore
 *
 * @return int|Redis The number of values in the new sorted set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zunionstore
 * @example
 * <pre>
 * $redis->del('k1');
 * $redis->del('k2');
 * $redis->del('k3');
 * $redis->del('ko1');
 * $redis->del('ko2');
 * $redis->del('ko3');
 *
 * $redis->zAdd('k1', 0, 'val0');
 * $redis->zAdd('k1', 1, 'val1');
 *
 * $redis->zAdd('k2', 2, 'val2');
 * $redis->zAdd('k2', 3, 'val3');
 *
 * $redis->zUnionStore('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')
 *
 * // Weighted zUnionStore
 * $redis->zUnionStore('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2', 'val3')
 * $redis->zUnionStore('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3', 'val1')
 * </pre>
 */
 public function zUnionStore($output, $zSetKeys, ?array $weights = null, $aggregateFunction = 'SUM') {}

/**
     * @param string     $Output
     * @param array      $ZSetKeys
     * @param array|null $Weights
     * @param string     $aggregateFunction
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zUnionStore(%parametersList%)')]
    public function zUnion($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}

/**
 * Creates an intersection of sorted sets given in second argument.
 * The result of the union will be stored in the sorted set defined by the first argument.
 * The third optional argument defines weights to apply to the sorted sets in input.
 * In this case, the weights will be multiplied by the score of each element in the sorted set
 * before applying the aggregation. The forth argument defines the AGGREGATE option which
 * specify how the results of the union are aggregated.
 *
 * @param string $output
 * @param array $zSetKeys
 * @param null|array $weights
 * @param string $aggregateFunction Either "SUM", "MIN", or "MAX":
 * defines the behaviour to use on duplicate entries during the zInterStore.
 *
 * @return int|Redis The number of values in the new sorted set or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zinterstore
 * @example
 * <pre>
 * $redis->del('k1');
 * $redis->del('k2');
 * $redis->del('k3');
 *
 * $redis->del('ko1');
 * $redis->del('ko2');
 * $redis->del('ko3');
 * $redis->del('ko4');
 *
 * $redis->zAdd('k1', 0, 'val0');
 * $redis->zAdd('k1', 1, 'val1');
 * $redis->zAdd('k1', 3, 'val3');
 *
 * $redis->zAdd('k2', 2, 'val1');
 * $redis->zAdd('k2', 3, 'val3');
 *
 * $redis->zInterStore('ko1', array('k1', 'k2')); // 2, 'ko1' => array('val1', 'val3')
 * $redis->zInterStore('ko2', array('k1', 'k2'), array(1, 1)); // 2, 'ko2' => array('val1', 'val3')
 *
 * // Weighted zInterStore
 * $redis->zInterStore('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
 * $redis->zInterStore('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
 * </pre>
 */
 public function zInterStore($output, $zSetKeys, array $weights = null, $aggregateFunction = 'SUM') {}

/**
     * @param $Output
     * @param $ZSetKeys
     * @param array|null $Weights
     * @param string $aggregateFunction
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->zInterStore(%parametersList%)')]
    public function zInter($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}

/**
 * Scan a sorted set for members, with optional pattern and count
 *
 * @param string $key String, the set to scan.
 * @param int &$iterator Long (reference), initialized to NULL.
 * @param string $pattern String (optional), the pattern to match.
 * @param int $count How many keys to return per iteration (Redis might return a different number).
 *
 * @return array|false|Redis PHPRedis will return matching keys from Redis, or FALSE when iteration is complete or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/zscan
 * @example
 * <pre>
 * $iterator = null;
 * while ($members = $redis-zscan('zset', $iterator)) {
 * foreach ($members as $member => $score) {
 * echo $member . ' => ' . $score . PHP_EOL;
 * }
 * }
 * </pre>
 */
 public function zScan($key, &$iterator, $pattern = null, $count = 0) {}

/**
 * Block until Redis can pop the highest or lowest scoring members from one or more ZSETs.
 * There are two commands (BZPOPMIN and BZPOPMAX for popping the lowest and highest scoring elements respectively.)
 *
 * @param string|array $key1
 * @param string|array $key2 ...
 * @param int $timeout
 *
 * @return array|Redis Either an array with the key member and score of the highest or lowest element or an empty array or Redis if in multi mode
 * if the timeout was reached without an element to pop.
 *
 * @throws RedisException
 *
 * @since >= 5.0
 * @link https://redis.io/commands/bzpopmax
 * @example
 * <pre>
 * // Wait up to 5 seconds to pop the *lowest* scoring member from sets `zs1` and `zs2`.
 * $redis->bzPopMin(['zs1', 'zs2'], 5);
 * $redis->bzPopMin('zs1', 'zs2', 5);
 *
 * // Wait up to 5 seconds to pop the *highest* scoring member from sets `zs1` and `zs2`
 * $redis->bzPopMax(['zs1', 'zs2'], 5);
 * $redis->bzPopMax('zs1', 'zs2', 5);
 * </pre>
 */
 public function bzPopMax($key1, $key2, $timeout) {}

/**
     * @param string|array $key1
     * @param string|array $key2 ...
     * @param int $timeout
     *
     * @return array|Redis Either an array with the key member and score of the highest or lowest element or an empty array or Redis if in multi mode
     * if the timeout was reached without an element to pop.
     *
     * @throws RedisException
     *
     * @see bzPopMax
     * @since >= 5.0
     * @link https://redis.io/commands/bzpopmin
     */
    public function bzPopMin($key1, $key2, $timeout) {}

/**
 * Can pop the highest scoring members from one ZSET.
 *
 * @param string $key
 * @param int $count
 *
 * @return array|Redis Either an array with the key member and score of the highest element or an empty array or Redis if in multi mode
 * if there is no element to pop.
 *
 * @throws RedisException
 *
 * @since >= 5.0
 * @link https://redis.io/commands/zpopmax
 * @example
 * <pre>
 * // Pop the *lowest* scoring member from set `zs1`.
 * $redis->zPopMax('zs1');
 * // Pop the *lowest* 3 scoring member from set `zs1`.
 * $redis->zPopMax('zs1', 3);
 * </pre>
 */
 public function zPopMax($key, $count = 1) {}

/**
 * Can pop the lowest scoring members from one ZSET.
 *
 * @param string $key
 * @param int $count
 *
 * @return array|Redis Either an array with the key member and score of the lowest element or an empty array or Redis if in multi mode
 * if there is no element to pop.
 *
 * @throws RedisException
 *
 * @since >= 5.0
 * @link https://redis.io/commands/zpopmin
 * @example
 * <pre>
 * // Pop the *lowest* scoring member from set `zs1`.
 * $redis->zPopMin('zs1');
 * // Pop the *lowest* 3 scoring member from set `zs1`.
 * $redis->zPopMin('zs1', 3);
 * </pre>
 */
 public function zPopMin($key, $count = 1) {}

/**
 * Adds a value to the hash stored at key. If this value is already in the hash, FALSE is returned.
 *
 * @param string $key
 * @param string $hashKey
 * @param string $value
 *
 * @return int|bool|Redis returns Redis if in multi mode
 * - 1 if value didn't exist and was added successfully,
 * - 0 if the value was already present and was replaced, FALSE if there was an error.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hset
 * @example
 * <pre>
 * $redis->del('h')
 * $redis->hSet('h', 'key1', 'hello'); // 1, 'key1' => 'hello' in the hash at "h"
 * $redis->hGet('h', 'key1'); // returns "hello"
 *
 * $redis->hSet('h', 'key1', 'plop'); // 0, value was replaced.
 * $redis->hGet('h', 'key1'); // returns "plop"
 * </pre>
 */
 public function hSet($key, $hashKey, $value) {}

/**
 * Adds a value to the hash stored at key only if this field isn't already in the hash.
 *
 * @param string $key
 * @param string $hashKey
 * @param string $value
 *
 * @return bool|Redis TRUE if the field was set, FALSE if it was already present or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hsetnx
 * @example
 * <pre>
 * $redis->del('h')
 * $redis->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
 * $redis->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the field
 * wasn't replaced.
 * </pre>
 */
 public function hSetNx($key, $hashKey, $value) {}

/**
     * Gets a value from the hash stored at key.
     * If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
     *
     * @param string $key
     * @param string $hashKey
     *
     * @return string|false|Redis The value, if the command executed successfully BOOL FALSE in case of failure or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/hget
     */
    public function hGet($key, $hashKey) {}

/**
 * Returns the length of a hash, in number of items
 *
 * @param string $key
 *
 * @return int|false|Redis the number of items in a hash, FALSE if the key doesn't exist or isn't a hash or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hlen
 * @example
 * <pre>
 * $redis->del('h')
 * $redis->hSet('h', 'key1', 'hello');
 * $redis->hSet('h', 'key2', 'plop');
 * $redis->hLen('h'); // returns 2
 * </pre>
 */
 public function hLen($key) {}

/**
 * Removes a values from the hash stored at key.
 * If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
 *
 * @param string $key
 * @param string $hashKey1
 * @param string ...$otherHashKeys
 *
 * @return int|bool|Redis Number of deleted fields or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hdel
 * @example
 * <pre>
 * $redis->hMSet('h',
 * array(
 * 'f1' => 'v1',
 * 'f2' => 'v2',
 * 'f3' => 'v3',
 * 'f4' => 'v4',
 * ));
 *
 * var_dump( $redis->hDel('h', 'f1') ); // int(1)
 * var_dump( $redis->hDel('h', 'f2', 'f3') ); // int(2)
 * s
 * var_dump( $redis->hGetAll('h') );
 * //// Output:
 * // array(1) {
 * // ["f4"]=> string(2) "v4"
 * // }
 * </pre>
 */
 public function hDel($key, $hashKey1, ...$otherHashKeys) {}

/**
 * Returns the keys in a hash, as an array of strings.
 *
 * @param string $key
 *
 * @return array|Redis An array of elements, the keys of the hash. This works like PHP's array_keys() or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hkeys
 * @example
 * <pre>
 * $redis->del('h');
 * $redis->hSet('h', 'a', 'x');
 * $redis->hSet('h', 'b', 'y');
 * $redis->hSet('h', 'c', 'z');
 * $redis->hSet('h', 'd', 't');
 * var_dump($redis->hKeys('h'));
 *
 * // Output:
 * // array(4) {
 * // [0]=>
 * // string(1) "a"
 * // [1]=>
 * // string(1) "b"
 * // [2]=>
 * // string(1) "c"
 * // [3]=>
 * // string(1) "d"
 * // }
 * // The order is random and corresponds to redis' own internal representation of the set structure.
 * </pre>
 */
 public function hKeys($key) {}

/**
 * Returns the values in a hash, as an array of strings.
 *
 * @param string $key
 *
 * @return array|Redis An array of elements, the values of the hash. This works like PHP's array_values() or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hvals
 * @example
 * <pre>
 * $redis->del('h');
 * $redis->hSet('h', 'a', 'x');
 * $redis->hSet('h', 'b', 'y');
 * $redis->hSet('h', 'c', 'z');
 * $redis->hSet('h', 'd', 't');
 * var_dump($redis->hVals('h'));
 *
 * // Output
 * // array(4) {
 * // [0]=>
 * // string(1) "x"
 * // [1]=>
 * // string(1) "y"
 * // [2]=>
 * // string(1) "z"
 * // [3]=>
 * // string(1) "t"
 * // }
 * // The order is random and corresponds to redis' own internal representation of the set structure.
 * </pre>
 */
 public function hVals($key) {}

/**
 * Returns the whole hash, as an array of strings indexed by strings.
 *
 * @param string $key
 *
 * @return array|Redis An array of elements, the contents of the hash or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hgetall
 * @example
 * <pre>
 * $redis->del('h');
 * $redis->hSet('h', 'a', 'x');
 * $redis->hSet('h', 'b', 'y');
 * $redis->hSet('h', 'c', 'z');
 * $redis->hSet('h', 'd', 't');
 * var_dump($redis->hGetAll('h'));
 *
 * // Output:
 * // array(4) {
 * // ["a"]=>
 * // string(1) "x"
 * // ["b"]=>
 * // string(1) "y"
 * // ["c"]=>
 * // string(1) "z"
 * // ["d"]=>
 * // string(1) "t"
 * // }
 * // The order is random and corresponds to redis' own internal representation of the set structure.
 * </pre>
 */
 public function hGetAll($key) {}

/**
 * Verify if the specified member exists in a key.
 *
 * @param string $key
 * @param string $hashKey
 *
 * @return bool|Redis If the member exists in the hash table, return TRUE, otherwise return FALSE or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hexists
 * @example
 * <pre>
 * $redis->hSet('h', 'a', 'x');
 * $redis->hExists('h', 'a'); // TRUE
 * $redis->hExists('h', 'NonExistingKey'); // FALSE
 * </pre>
 */
 public function hExists($key, $hashKey) {}

/**
 * Increments the value of a member from a hash by a given amount.
 *
 * @param string $key
 * @param string $hashKey
 * @param int $value (integer) value that will be added to the member's value
 *
 * @return int|Redis the new value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hincrby
 * @example
 * <pre>
 * $redis->del('h');
 * $redis->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
 * $redis->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
 * </pre>
 */
 public function hIncrBy($key, $hashKey, $value) {}

/**
 * Increment the float value of a hash field by the given amount
 *
 * @param string $key
 * @param string $field
 * @param float $increment
 *
 * @return float|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hincrbyfloat
 * @example
 * <pre>
 * $redis = new Redis();
 * $redis->connect('127.0.0.1');
 * $redis->hset('h', 'float', 3);
 * $redis->hset('h', 'int', 3);
 * var_dump( $redis->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)
 *
 * var_dump( $redis->hGetAll('h') );
 *
 * // Output
 * array(2) {
 * ["float"]=>
 * string(3) "4.5"
 * ["int"]=>
 * string(1) "3"
 * }
 * </pre>
 */
 public function hIncrByFloat($key, $field, $increment) {}

/**
 * Fills in a whole hash. Non-string values are converted to string, using the standard (string) cast.
 * NULL values are stored as empty strings
 *
 * @param string $key
 * @param array $hashKeys key → value array
 *
 * @return bool|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hmset
 * @example
 * <pre>
 * $redis->del('user:1');
 * $redis->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
 * $redis->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.
 * </pre>
 */
 public function hMSet($key, $hashKeys) {}

/**
 * Retrieve the values associated to the specified fields in the hash.
 *
 * @param string $key
 * @param array $hashKeys
 *
 * @return array|Redis Array An array of elements, the values of the specified fields in the hash, or Redis if in multi mode
 * with the hash keys as array keys.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hmget
 * @example
 * <pre>
 * $redis->del('h');
 * $redis->hSet('h', 'field1', 'value1');
 * $redis->hSet('h', 'field2', 'value2');
 * $redis->hMGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' => 'value2')
 * </pre>
 */
 public function hMGet($key, $hashKeys) {}

/**
 * Scan a HASH value for members, with an optional pattern and count.
 *
 * @param string $key
 * @param int &$iterator
 * @param string $pattern Optional pattern to match against.
 * @param int $count How many keys to return in a go (only a sugestion to Redis).
 *
 * @return array|Redis An array of members that match our pattern or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/hscan
 * @example
 * <pre>
 * // $iterator = null;
 * // while($elements = $redis->hscan('hash', $iterator)) {
 * // foreach($elements as $key => $value) {
 * // echo $key . ' => ' . $value . PHP_EOL;
 * // }
 * // }
 * </pre>
 */
 public function hScan($key, &$iterator, $pattern = null, $count = 0) {}

/**
     * Get the string length of the value associated with field in the hash stored at key
     *
     * @param string $key
     * @param string $field
     *
     * @return int|Redis the string length of the value associated with field, or zero when field is not present in the hash or Redis if in multi mode
     * or key does not exist at all.
     *
     * @throws RedisException
     *
     * @link https://redis.io/commands/hstrlen
     * @since >= 3.2
     */
    public function hStrLen(string $key, string $field) {}

/**
 * Add one or more geospatial items to the specified key.
 * This function must be called with at least one longitude, latitude, member triplet.
 *
 * @param string $key
 * @param float $longitude
 * @param float $latitude
 * @param string $member
 *
 * @return int|Redis The number of elements added to the geospatial key or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/geoadd
 * @since >= 3.2
 *
 * @example
 * <pre>
 * $redis->del("myplaces");
 *
 * // Since the key will be new, $result will be 2
 * $result = $redis->geoAdd(
 * "myplaces",
 * -122.431, 37.773, "San Francisco",
 * -157.858, 21.315, "Honolulu"
 * ); // 2
 * </pre>
 */
 public function geoAdd($key, $longitude, $latitude, $member) {}

/**
     * Retrieve Geohash strings for one or more elements of a geospatial index.

* @param string $key
 * @param string ...$member variadic list of members
 *
 * @return array|Redis One or more Redis Geohash encoded strings or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/geohash
 * @since >= 3.2
 *
 * @example
 * <pre>
 * $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
 * $hashes = $redis->geoHash("hawaii", "Honolulu", "Maui");
 * var_dump($hashes);
 * // Output: array(2) {
 * // [0]=>
 * // string(11) "87z9pyek3y0"
 * // [1]=>
 * // string(11) "8e8y6d5jps0"
 * // }
 * </pre>
 */
 public function geoHash($key, ...$member) {}

/**
 * Return longitude, latitude positions for each requested member.
 *
 * @param string $key
 * @param string $member
 * @return array|Redis One or more longitude/latitude positions or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/geopos
 * @since >= 3.2
 *
 * @example
 * <pre>
 * $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
 * $positions = $redis->geoPos("hawaii", "Honolulu", "Maui");
 * var_dump($positions);
 *
 * // Output:
 * array(2) {
 * [0]=> array(2) {
 * [0]=> string(22) "-157.85800248384475708"
 * [1]=> string(19) "21.3060004581273077"
 * }
 * [1]=> array(2) {
 * [0]=> string(22) "-156.33099943399429321"
 * [1]=> string(20) "20.79799924753607598"
 * }
 * }
 * </pre>
 */
 public function geoPos(string $key, string $member) {}

/**
 * Return the distance between two members in a geospatial set.
 *
 * If units are passed it must be one of the following values:
 * - 'm' => Meters
 * - 'km' => Kilometers
 * - 'mi' => Miles
 * - 'ft' => Feet
 *
 * @param string $key
 * @param string $member1
 * @param string $member2
 * @param string|null $unit
 *
 * @return float|Redis The distance between the two passed members in the units requested (meters by default) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/geodist
 * @since >= 3.2
 *
 * @example
 * <pre>
 * $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
 *
 * $meters = $redis->geoDist("hawaii", "Honolulu", "Maui");
 * $kilometers = $redis->geoDist("hawaii", "Honolulu", "Maui", 'km');
 * $miles = $redis->geoDist("hawaii", "Honolulu", "Maui", 'mi');
 * $feet = $redis->geoDist("hawaii", "Honolulu", "Maui", 'ft');
 *
 * echo "Distance between Honolulu and Maui:\n";
 * echo " meters : $meters\n";
 * echo " kilometers: $kilometers\n";
 * echo " miles : $miles\n";
 * echo " feet : $feet\n";
 *
 * // Bad unit
 * $inches = $redis->geoDist("hawaii", "Honolulu", "Maui", 'in');
 * echo "Invalid unit returned:\n";
 * var_dump($inches);
 *
 * // Output
 * Distance between Honolulu and Maui:
 * meters : 168275.204
 * kilometers: 168.2752
 * miles : 104.5616
 * feet : 552084.0028
 * Invalid unit returned:
 * bool(false)
 * </pre>
 */
 public function geoDist($key, $member1, $member2, $unit = null) {}

/**
 * Return members of a set with geospatial information that are within the radius specified by the caller.
 *
 * @param $key
 * @param $longitude
 * @param $latitude
 * @param $radius
 * @param $unit
 * @param array|null $options
 * <pre>
 * |Key |Value |Description |
 * |------------|---------------|---------------------------------------------------|
 * |COUNT |integer > 0 |Limit how many results are returned |
 * | |WITHCOORD |Return longitude and latitude of matching members |
 * | |WITHDIST |Return the distance from the center |
 * | |WITHHASH |Return the raw geohash-encoded score |
 * | |ASC |Sort results in ascending order |
 * | |DESC |Sort results in descending order |
 * |STORE |key |Store results in key |
 * |STOREDIST |key |Store the results as distances in key |
 * </pre>
 * Note: It doesn't make sense to pass both ASC and DESC options but if both are passed
 * the last one passed will be used.
 * Note: When using STORE[DIST] in Redis Cluster, the store key must has to the same slot as
 * the query key or you will get a CROSSLOT error.
 * @return mixed|Redis When no STORE option is passed, this function returns an array of results or Redis if in multi mode
 * If it is passed this function returns the number of stored entries.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/georadius
 * @since >= 3.2
 * @example
 * <pre>
 * // Add some cities
 * $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
 *
 * echo "Within 300 miles of Honolulu:\n";
 * var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi'));
 *
 * echo "\nWithin 300 miles of Honolulu with distances:\n";
 * $options = ['WITHDIST'];
 * var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
 *
 * echo "\nFirst result within 300 miles of Honolulu with distances:\n";
 * $options['count'] = 1;
 * var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
 *
 * echo "\nFirst result within 300 miles of Honolulu with distances in descending sort order:\n";
 * $options[] = 'DESC';
 * var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
 *
 * // Output
 * Within 300 miles of Honolulu:
 * array(2) {
 * [0]=> string(8) "Honolulu"
 * [1]=> string(4) "Maui"
 * }
 *
 * Within 300 miles of Honolulu with distances:
 * array(2) {
 * [0]=>
 * array(2) {
 * [0]=>
 * string(8) "Honolulu"
 * [1]=>
 * string(6) "0.0002"
 * }
 * [1]=>
 * array(2) {
 * [0]=>
 * string(4) "Maui"
 * [1]=>
 * string(8) "104.5615"
 * }
 * }
 *
 * First result within 300 miles of Honolulu with distances:
 * array(1) {
 * [0]=>
 * array(2) {
 * [0]=>
 * string(8) "Honolulu"
 * [1]=>
 * string(6) "0.0002"
 * }
 * }
 *
 * First result within 300 miles of Honolulu with distances in descending sort order:
 * array(1) {
 * [0]=>
 * array(2) {
 * [0]=>
 * string(4) "Maui"
 * [1]=>
 * string(8) "104.5615"
 * }
 * }
 * </pre>
 */
 public function geoRadius($key, $longitude, $latitude, $radius, $unit, array $options = null) {}

/**
 * This method is identical to geoRadius except that instead of passing a longitude and latitude as the "source"
 * you pass an existing member in the geospatial set
 *
 * @param string $key
 * @param string $member
 * @param $radius
 * @param $units
 * @param array|null $options see georadius
 *
 * @return array|Redis The zero or more entries that are close enough to the member given the distance and radius specified or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/georadiusbymember
 * @since >= 3.2
 * @see georadius
 * @example
 * <pre>
 * $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
 *
 * echo "Within 300 miles of Honolulu:\n";
 * var_dump($redis->geoRadiusByMember("hawaii", "Honolulu", 300, 'mi'));
 *
 * echo "\nFirst match within 300 miles of Honolulu:\n";
 * var_dump($redis->geoRadiusByMember("hawaii", "Honolulu", 300, 'mi', ['count' => 1]));
 *
 * // Output
 * Within 300 miles of Honolulu:
 * array(2) {
 * [0]=> string(8) "Honolulu"
 * [1]=> string(4) "Maui"
 * }
 *
 * First match within 300 miles of Honolulu:
 * array(1) {
 * [0]=> string(8) "Honolulu"
 * }
 * </pre>
 */
 public function geoRadiusByMember($key, $member, $radius, $units, array $options = null) {}

/**
 * Get or Set the redis config keys.
 *
 * @param string $operation either `GET` or `SET`
 * @param string $key for `SET`, glob-pattern for `GET`
 * @param string|mixed $value optional string (only for `SET`)
 *
 * @return array|Redis Associative array for `GET`, key -> value or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/config-get
 * @example
 * <pre>
 * $redis->config("GET", "*max-*-entries*");
 * $redis->config("SET", "dir", "/var/run/redis/dumps/");
 * </pre>
 */
 public function config($operation, $key, $value = '') {}

/**
 * Evaluate a LUA script serverside
 *
 * @param string $script
 * @param array $args
 * @param int $numKeys
 *
 * @return mixed|Redis What is returned depends on what the LUA script itself returns, which could be a scalar value or Redis if in multi mode
 * (int/string), or an array. Arrays that are returned can also contain other arrays, if that's how it was set up in
 * your LUA script. If there is an error executing the LUA script, the getLastError() function can tell you the
 * message that came back from Redis (e.g. compile error).
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/eval
 * @example
 * <pre>
 * $redis->eval("return 1"); // Returns an integer: 1
 * $redis->eval("return {1,2,3}"); // Returns Array(1,2,3)
 * $redis->del('mylist');
 * $redis->rpush('mylist','a');
 * $redis->rpush('mylist','b');
 * $redis->rpush('mylist','c');
 * // Nested response: Array(1,2,3,Array('a','b','c'));
 * $redis->eval("return {1,2,3,redis.call('lrange','mylist',0,-1)}}");
 * </pre>
 */
 public function eval($script, $args = [], $numKeys = 0) {}

/**
     * @param   string  $script
     * @param   array   $args
     * @param   int     $numKeys
     * @return  mixed|Redis   @see eval() , returns Redis if in multi mode
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->eval(%parametersList%)')]
    public function evaluate($script, $args = [], $numKeys = 0) {}

/**
 * Evaluate a LUA script serverside, from the SHA1 hash of the script instead of the script itself.
 * In order to run this command Redis will have to have already loaded the script, either by running it or via
 * the SCRIPT LOAD command.
 *
 * @param string $scriptSha
 * @param array $args
 * @param int $numKeys
 *
 * @return mixed|Redis @see eval() , returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @see eval()
 * @link https://redis.io/commands/evalsha
 * @example
 * <pre>
 * $script = 'return 1';
 * $sha = $redis->script('load', $script);
 * $redis->evalSha($sha); // Returns 1
 * </pre>
 */
 public function evalSha($scriptSha, $args = [], $numKeys = 0) {}

/**
     * @param string $scriptSha
     * @param array  $args
     * @param int    $numKeys
     *
     * @throws RedisException
     */
    #[Deprecated(replacement: '%class%->evalSha(%parametersList%)')]
    public function evaluateSha($scriptSha, $args = [], $numKeys = 0) {}

/**
 * Execute the Redis SCRIPT command to perform various operations on the scripting subsystem.
 * @param string $command load | flush | kill | exists
 * @param string $script
 *
 * @return mixed|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/script-load
 * @link https://redis.io/commands/script-kill
 * @link https://redis.io/commands/script-flush
 * @link https://redis.io/commands/script-exists
 * @example
 * <pre>
 * $redis->script('load', $script);
 * $redis->script('flush');
 * $redis->script('kill');
 * $redis->script('exists', $script1, [$script2, $script3, ...]);
 * </pre>
 *
 * SCRIPT LOAD will return the SHA1 hash of the passed script on success, and FALSE on failure.
 * SCRIPT FLUSH should always return TRUE
 * SCRIPT KILL will return true if a script was able to be killed and false if not
 * SCRIPT EXISTS will return an array with TRUE or FALSE for each passed script
 */
 public function script($command, $script) {}

/**
 * The last error message (if any)
 *
 * @return string|null A string with the last returned script based error message, or NULL if there is no error
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->eval('this-is-not-lua');
 * $err = $redis->getLastError();
 * // "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"
 * </pre>
 */
 public function getLastError() {}

/**
 * Clear the last error message
 *
 * @return bool true
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->set('x', 'a');
 * $redis->incr('x');
 * $err = $redis->getLastError();
 * // "ERR value is not an integer or out of range"
 * $redis->clearLastError();
 * $err = $redis->getLastError();
 * // NULL
 * </pre>
 */
 public function clearLastError() {}

/**
 * Issue the CLIENT command with various arguments.
 * The Redis CLIENT command can be used in four ways:
 * - CLIENT LIST
 * - CLIENT GETNAME
 * - CLIENT SETNAME [name]
 * - CLIENT KILL [ip:port]
 *
 * @param string $command
 * @param string $value
 * @return mixed This will vary depending on which client command was executed:
 * - CLIENT LIST will return an array of arrays with client information.
 * - CLIENT GETNAME will return the client name or false if none has been set
 * - CLIENT SETNAME will return true if it can be set and false if not
 * - CLIENT KILL will return true if the client can be killed, and false if not
 *
 * @throws RedisException
 *
 * Note: phpredis will attempt to reconnect so you can actually kill your own connection but may not notice losing it!
 *
 * @link https://redis.io/commands/client-list
 * @link https://redis.io/commands/client-getname
 * @link https://redis.io/commands/client-setname
 * @link https://redis.io/commands/client-kill
 *
 * @example
 * <pre>
 * $redis->client('list'); // Get a list of clients
 * $redis->client('getname'); // Get the name of the current connection
 * $redis->client('setname', 'somename'); // Set the name of the current connection
 * $redis->client('kill', <ip:port>); // Kill the process at ip:port
 * </pre>
 */
 public function client($command, $value = '') {}

/**
 * A utility method to prefix the value with the prefix setting for phpredis.
 *
 * @param mixed $value The value you wish to prefix
 *
 * @return string If a prefix is set up, the value now prefixed
 * If there is no prefix, the value will be returned unchanged.
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
 * $redis->_prefix('my-value'); // Will return 'my-prefix:my-value'
 * </pre>
 */
 public function _prefix($value) {}

/**
 * A utility method to unserialize data with whatever serializer is set up. If there is no serializer set, the
 * value will be returned unchanged. If there is a serializer set up, and the data passed in is malformed, an
 * exception will be thrown. This can be useful if phpredis is serializing values, and you return something from
 * redis in a LUA script that is serialized.
 *
 * @param string $value The value to be unserialized
 *
 * @return mixed
 * @example
 * <pre>
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
 * $redis->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return Array(1,2,3)
 * </pre>
 */
 public function _unserialize($value) {}

/**
 * A utility method to serialize values manually. This method allows you to serialize a value with whatever
 * serializer is configured, manually. This can be useful for serialization/unserialization of data going in
 * and out of EVAL commands as phpredis can't automatically do this itself. Note that if no serializer is
 * set, phpredis will change Array values to 'Array', and Objects to 'Object'.
 *
 * @param mixed $value The value to be serialized.
 *
 * @return mixed
 * @example
 * <pre>
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
 * $redis->_serialize("foo"); // returns "foo"
 * $redis->_serialize(Array()); // Returns "Array"
 * $redis->_serialize(new stdClass()); // Returns "Object"
 *
 * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
 * $redis->_serialize("foo"); // Returns 's:3:"foo";'
 * </pre>
 */
 public function _serialize($value) {}

/**
 * Dump a key out of a redis database, the value of which can later be passed into redis using the RESTORE command.
 * The data that comes out of DUMP is a binary representation of the key as Redis stores it.
 * @param string $key
 *
 * @return string|false The Redis encoded value of the key, or FALSE if the key doesn't exist
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/dump
 * @example
 * <pre>
 * $redis->set('foo', 'bar');
 * $val = $redis->dump('foo'); // $val will be the Redis encoded key value
 * </pre>
 */
 public function dump($key) {}

/**
 * Restore a key from the result of a DUMP operation.
 *
 * @param string $key The key name
 * @param int $ttl How long the key should live (if zero, no expire will be set on the key)
 * @param string $value (binary). The Redis encoded key value (from DUMP)
 *
 * @return bool
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/restore
 * @example
 * <pre>
 * $redis->set('foo', 'bar');
 * $val = $redis->dump('foo');
 * $redis->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'
 * </pre>
 */
 public function restore($key, $ttl, $value) {}

/**
 * Migrates a key to a different Redis instance.
 *
 * @param string $host The destination host
 * @param int $port The TCP port to connect to.
 * @param string $key The key to migrate.
 * @param int $db The target DB.
 * @param int $timeout The maximum amount of time given to this transfer.
 * @param bool $copy Should we send the COPY flag to redis.
 * @param bool $replace Should we send the REPLACE flag to redis.
 *
 * @return bool
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/migrate
 * @example
 * <pre>
 * $redis->migrate('backup', 6379, 'foo', 0, 3600);
 * </pre>
 */
 public function migrate($host, $port, $key, $db, $timeout, $copy = false, $replace = false) {}

/**
 * Return the current Redis server time.
 *
 * @return array If successful, the time will come back as an associative array with element zero being the
 * unix timestamp, and element one being microseconds.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/time
 * @example
 * <pre>
 * var_dump( $redis->time() );
 * // array(2) {
 * // [0] => string(10) "1342364352"
 * // [1] => string(6) "253002"
 * // }
 * </pre>
 */
 public function time() {}

/**
 * Scan the keyspace for keys
 *
 * @param int &$iterator Iterator, initialized to NULL.
 * @param string $pattern Pattern to match.
 * @param int $count Count of keys per iteration (only a suggestion to Redis).
 *
 * @return array|false|Redis This function will return an array of keys or FALSE if there are no more keys or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/scan
 * @example
 * <pre>
 * $iterator = null;
 * while(false !== ($keys = $redis->scan($iterator))) {
 * foreach($keys as $key) {
 * echo $key . PHP_EOL;
 * }
 * }
 * </pre>
 */
 public function scan(&$iterator, $pattern = null, $count = 0) {}

/**
     * Adds all the element arguments to the HyperLogLog data structure stored at the key.
     *
     * @param string $key
     * @param array  $elements
     *
     * @return bool|Redis returns Redis if in multi mode
     *
     * @throws RedisException
     *
     * @link    https://redis.io/commands/pfadd
     * @example $redis->pfAdd('key', array('elem1', 'elem2'))
     */
    public function pfAdd($key, array $elements) {}

/**
 * When called with a single key, returns the approximated cardinality computed by the HyperLogLog data
 * structure stored at the specified variable, which is 0 if the variable does not exist.
 *
 * @param string|array $key
 *
 * @return int|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pfcount
 * @example
 * <pre>
 * $redis->pfAdd('key1', array('elem1', 'elem2'));
 * $redis->pfAdd('key2', array('elem3', 'elem2'));
 * $redis->pfCount('key1'); // int(2)
 * $redis->pfCount(array('key1', 'key2')); // int(3)
 * </pre>
 */
 public function pfCount($key) {}

/**
 * Merge multiple HyperLogLog values into an unique value that will approximate the cardinality
 * of the union of the observed Sets of the source HyperLogLog structures.
 *
 * @param string $destKey
 * @param array $sourceKeys
 *
 * @return bool|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/pfmerge
 * @example
 * <pre>
 * $redis->pfAdd('key1', array('elem1', 'elem2'));
 * $redis->pfAdd('key2', array('elem3', 'elem2'));
 * $redis->pfMerge('key3', array('key1', 'key2'));
 * $redis->pfCount('key3'); // int(3)
 * </pre>
 */
 public function pfMerge($destKey, array $sourceKeys) {}

/**
 * Send arbitrary things to the redis server.
 *
 * @param string $command Required command to send to the server.
 * @param mixed $arguments Optional variable amount of arguments to send to the server.
 *
 * @return mixed|Redis returns Redis if in multi mode
 *
 * @throws RedisException
 *
 * @example
 * <pre>
 * $redis->rawCommand('SET', 'key', 'value'); // bool(true)
 * $redis->rawCommand('GET", 'key'); // string(5) "value"
 * </pre>
 */
 public function rawCommand($command, $arguments) {}

/**
     * Detect whether we're in ATOMIC/MULTI/PIPELINE mode.
     *
     * @return int|Redis Either Redis::ATOMIC, Redis::MULTI or Redis::PIPELINE or Redis if in multi mode
     *
     * @throws RedisException
     *
     * @example $redis->getMode();
     */
    public function getMode() {}

/**
 * Acknowledge one or more messages on behalf of a consumer group.
 *
 * @param string $stream
 * @param string $group
 * @param array $messages
 *
 * @return int|Redis The number of messages Redis reports as acknowledged or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xack
 * @example
 * <pre>
 * $redis->xAck('stream', 'group1', ['1530063064286-0', '1530063064286-1']);
 * </pre>
 */
 public function xAck($stream, $group, $messages) {}

/**
 * Add a message to a stream
 *
 * @param string $key
 * @param string $id
 * @param array $messages
 * @param int $maxLen
 * @param bool $isApproximate
 *
 * @return string|Redis The added message ID or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xadd
 * @example
 * <pre>
 * $redis->xAdd('mystream', "*", ['field' => 'value']);
 * $redis->xAdd('mystream', "*", ['field' => 'value'], 10);
 * $redis->xAdd('mystream', "*", ['field' => 'value'], 10, true);
 * </pre>
 */
 public function xAdd($key, $id, $messages, $maxLen = 0, $isApproximate = false) {}

/**
 * Claim ownership of one or more pending messages
 *
 * @param string $key
 * @param string $group
 * @param string $consumer
 * @param int $minIdleTime
 * @param array $ids
 * @param array $options ['IDLE' => $value, 'TIME' => $value, 'RETRYCOUNT' => $value, 'FORCE', 'JUSTID']
 *
 * @return array|Redis Either an array of message IDs along with corresponding data, or just an array of IDs or Redis if in multi mode
 * (if the 'JUSTID' option was passed).
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xclaim
 * @example
 * <pre>
 * $ids = ['1530113681011-0', '1530113681011-1', '1530113681011-2'];
 *
 * // Without any options
 * $redis->xClaim('mystream', 'group1', 'myconsumer1', 0, $ids);
 *
 * // With options
 * $redis->xClaim(
 * 'mystream', 'group1', 'myconsumer2', 0, $ids,
 * [
 * 'IDLE' => time() * 1000,
 * 'RETRYCOUNT' => 5,
 * 'FORCE',
 * 'JUSTID'
 * ]
 * );
 * </pre>
 */
 public function xClaim($key, $group, $consumer, $minIdleTime, $ids, $options = []) {}

/**
 * Delete one or more messages from a stream
 *
 * @param string $key
 * @param array $ids
 *
 * @return int|Redis The number of messages removed or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xdel
 * @example
 * <pre>
 * $redis->xDel('mystream', ['1530115304877-0', '1530115305731-0']);
 * </pre>
 */
 public function xDel($key, $ids) {}

/**
 * @param string $operation e.g.: 'HELP', 'SETID', 'DELGROUP', 'CREATE', 'DELCONSUMER'
 * @param string $key
 * @param string $group
 * @param string $msgId
 * @param bool $mkStream
 *
 * @return mixed|Redis This command returns different types depending on the specific XGROUP command executed or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xgroup
 * @example
 * <pre>
 * $redis->xGroup('CREATE', 'mystream', 'mygroup', 0);
 * $redis->xGroup('CREATE', 'mystream', 'mygroup', 0, true); // create stream
 * $redis->xGroup('DESTROY', 'mystream', 'mygroup');
 * </pre>
 */
 public function xGroup($operation, $key, $group, $msgId = '', $mkStream = false) {}

/**
 * Get information about a stream or consumer groups
 *
 * @param string $operation e.g.: 'CONSUMERS', 'GROUPS', 'STREAM', 'HELP'
 * @param string $stream
 * @param string $group
 *
 * @return mixed|Redis This command returns different types depending on which subcommand is used or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xinfo
 * @example
 * <pre>
 * $redis->xInfo('STREAM', 'mystream');
 * </pre>
 */
 public function xInfo($operation, $stream, $group) {}

/**
 * Get the length of a given stream.
 *
 * @param string $stream
 *
 * @return int|Redis The number of messages in the stream or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xlen
 * @example
 * <pre>
 * $redis->xLen('mystream');
 * </pre>
 */
 public function xLen($stream) {}

/**
 * Get information about pending messages in a given stream
 *
 * @param string $stream
 * @param string $group
 * @param string $start
 * @param string $end
 * @param int $count
 * @param string $consumer
 *
 * @return array|Redis Information about the pending messages, in various forms depending on or Redis if in multi mode
 * the specific invocation of XPENDING.
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xpending
 * @example
 * <pre>
 * $redis->xPending('mystream', 'mygroup');
 * $redis->xPending('mystream', 'mygroup', '-', '+', 1, 'consumer-1');
 * </pre>
 */
 public function xPending($stream, $group, $start = null, $end = null, $count = null, $consumer = null) {}

/**
 * Get a range of messages from a given stream
 *
 * @param string $stream
 * @param string $start
 * @param string $end
 * @param int $count
 *
 * @return array|Redis The messages in the stream within the requested range or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xrange
 * @example
 * <pre>
 * // Get everything in this stream
 * $redis->xRange('mystream', '-', '+');
 * // Only the first two messages
 * $redis->xRange('mystream', '-', '+', 2);
 * </pre>
 */
 public function xRange($stream, $start, $end, $count = null) {}

/**
 * Read data from one or more streams and only return IDs greater than sent in the command.
 *
 * @param array $streams
 * @param int|string $count
 * @param int|string $block
 *
 * @return array|Redis The messages in the stream newer than the IDs passed to Redis (if any) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xread
 * @example
 * <pre>
 * $redis->xRead(['stream1' => '1535222584555-0', 'stream2' => '1535222584555-0']);
 * </pre>
 */
 public function xRead($streams, $count = null, $block = null) {}

/**
 * This method is similar to xRead except that it supports reading messages for a specific consumer group.
 *
 * @param string $group
 * @param string $consumer
 * @param array $streams
 * @param int|null $count
 * @param int|null $block
 *
 * @return array|Redis The messages delivered to this consumer group (if any) or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xreadgroup
 * @example
 * <pre>
 * // Consume messages for 'mygroup', 'consumer1'
 * $redis->xReadGroup('mygroup', 'consumer1', ['s1' => 0, 's2' => 0]);
 * // Read a single message as 'consumer2' for up to a second until a message arrives.
 * $redis->xReadGroup('mygroup', 'consumer2', ['s1' => 0, 's2' => 0], 1, 1000);
 * </pre>
 */
 public function xReadGroup($group, $consumer, $streams, $count = null, $block = null) {}

/**
 * This is identical to xRange except the results come back in reverse order.
 * Also note that Redis reverses the order of "start" and "end".
 *
 * @param string $stream
 * @param string $end
 * @param string $start
 * @param int $count
 *
 * @return array|Redis The messages in the range specified or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xrevrange
 * @example
 * <pre>
 * $redis->xRevRange('mystream', '+', '-');
 * </pre>
 */
 public function xRevRange($stream, $end, $start, $count = null) {}

/**
 * Trim the stream length to a given maximum.
 * If the "approximate" flag is pasesed, Redis will use your size as a hint but only trim trees in whole nodes
 * (this is more efficient)
 *
 * @param string $stream
 * @param int $maxLen
 * @param bool $isApproximate
 *
 * @return int|Redis The number of messages trimed from the stream or Redis if in multi mode
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/xtrim
 * @example
 * <pre>
 * // Trim to exactly 100 messages
 * $redis->xTrim('mystream', 100);
 * // Let Redis approximate the trimming
 * $redis->xTrim('mystream', 100, true);
 * </pre>
 */
 public function xTrim($stream, $maxLen, $isApproximate) {}

/**
 * Adds a values to the set value stored at key.
 *
 * @param string $key Required key
 * @param array $values Required values
 *
 * @return int|bool|Redis The number of elements added to the set or Redis if in multi mode
 * If this value is already in the set, FALSE is returned
 *
 * @throws RedisException
 *
 * @link https://redis.io/commands/sadd
 * @link https://github.com/phpredis/phpredis/commit/3491b188e0022f75b938738f7542603c7aae9077
 * @since phpredis 2.2.8
 * @example
 * <pre>
 * $redis->sAddArray('k', array('v1')); // boolean
 * $redis->sAddArray('k', array('v1', 'v2', 'v3')); // boolean
 * </pre>
 */
 public function sAddArray($key, array $values) {}
}

class RedisException extends Exception {}