<?php

/**

* @generate-function-entries

* @generate-legacy-arginfo

* @generate-class-entries

*/

/** @not-serializable */

class RedisCluster {

/**

* Used to configure how `PhpRedis` will fail over to replica nodes when a

* primary node fails to respond.

*

* @var int

* @cvalue REDIS_OPT_FAILOVER

*

*/

public const OPT_SLAVE_FAILOVER = UNKNOWN;

/**

* Never read from replicas.

*

* @var int

* @cvalue REDIS_FAILOVER_NONE

*

*/

public const FAILOVER_NONE = UNKNOWN;

/**

* Attempt to read from replicas when the primary errors out or is down.

*

* @var int

* @cvalue REDIS_FAILOVER_ERROR

*

*/

public const FAILOVER_ERROR = UNKNOWN;

/**

* Distribute read-only commands at random between the primary and

* replica(s).

*

* @var int

* @cvalue REDIS_FAILOVER_DISTRIBUTE

*

*/

public const FAILOVER_DISTRIBUTE = UNKNOWN;

/**

* Distribute read-only commands between the replicas only.

*

* @var int

* @cvalue REDIS_FAILOVER_DISTRIBUTE_SLAVES

*

*/

public const FAILOVER_DISTRIBUTE_SLAVES = UNKNOWN;

public function __construct(string|null $name, ?array $seeds = null, int|float $timeout = 0, int|float $read_timeout = 0, bool $persistent = false, #[\SensitiveParameter] mixed $auth = null, ?array $context = null);

/**

* @see \Redis::_compress()

*/

public function _compress(string $value): string;

/**

* @see \Redis::_uncompress()

*/

public function _uncompress(string $value): string;

/**

* @see \Redis::_serialize()

*/

public function _serialize(mixed $value): bool|string;

/**

* @see \Redis::_unserialize()

*/

public function _unserialize(string $value): mixed;

/**

* @see \Redis::_pack()

*/

public function _pack(mixed $value): string;

/**

* @see \Redis::_digest()

*/

public function _digest(mixed $value): string;

/**

* @see \Redis::_unpack()

*/

public function _unpack(string $value): mixed;

/**

* @see \Redis::_prefix()

*/

public function _prefix(string $key): bool|string;

public function _masters(): array;

public function _redir(): string|null;

/**

* @see \Redis::acl()

*/

public function acl(string|array $key_or_address, string $subcmd, string ...$args): mixed;

/**

* @see \Redis::append()

*/

public function append(string $key, mixed $value): RedisCluster|bool|int;

/**

* @see \Redis::bgrewriteaof()

*/

public function bgrewriteaof(string|array $key_or_address): RedisCluster|bool;

/**

* @see \Redis::wait()

*/

public function wait(string|array $key_or_address, int $numreplicas, int $timeout): RedisCluster|int|false;

/**

* @see \Redis::waitaof()

*/

public function waitaof(string|array $key_or_address, int $numlocal,

int $numreplicas, int $timeout): RedisCluster|array|false;

/**

* @see \Redis::bgSave()

*/

public function bgsave(string|array $key_or_address): RedisCluster|bool;

/**

* @see \Redis::bitcount()

*/

public function bitcount(string $key, int $start = 0, int $end = -1, bool $bybit = false): RedisCluster|bool|int;

/**

* @see \Redis::bitop()

*/

public function bitop(string $operation, string $deskey, string $srckey, string ...$otherkeys): RedisCluster|bool|int;

/**

* Return the position of the first bit set to 0 or 1 in a string.

*

* @see https://redis.io/docs/latest/commands/bitpos/

*

* @param string $key The key to check (must be a string)

* @param bool $bit Whether to look for an unset (0) or set (1) bit.

* @param int $start Where in the string to start looking.

* @param int $end Where in the string to stop looking.

* @param bool $bybit If true, Redis will treat $start and $end as BIT values and not bytes, so if start

* were 0 and end were 2, Redis would search the first three bits.

*/

public function bitpos(string $key, bool $bit, int $start = 0, int $end = -1, bool $bybit = false): RedisCluster|int|false;

/**

* @see \Redis::blPop()

*/

public function blpop(string|array $key, string|float|int $timeout_or_key, mixed ...$extra_args): RedisCluster|array|null|false;

/**

* @see \Redis::brPop()

*/

public function brpop(string|array $key, string|float|int $timeout_or_key, mixed ...$extra_args): RedisCluster|array|null|false;

/**

* @see \Redis::brpoplpush()

*/

public function brpoplpush(string $srckey, string $deskey, int $timeout): mixed;

/**

* Move an element from one list into another.

*

* @see \Redis::lMove()

*/

public function lmove(string $src, string $dst, string $wherefrom, string $whereto): RedisCluster|string|false;

/**

* Move one or more elements from one list to another.

*

* @param string $src The source list

* @param string $dst The destination list

* @param string $wherefrom Where in the source list to extract the element.

* @param string $whereto Where in the destination list to put the element.

* @param null|array $options An array of options to modify how the command behaves.

*

* @return RedisCluster|array|false The element(s) removed from the source list.

*

* @see https://redis.io/docs/latest/commands/lmovem/

*

* @example

* $redis->rPush('{lists}:numbers', 'one', 'two', 'three');

* $redis->lMovem('{lists}:numbers', '{lists}:odds', Redis::LEFT, Redis::LEFT, ['COUNT' => [2, 'BULK']]);

*/

public function lmovem(string $src, string $dst, string $wherefrom, string $whereto, ?array $options = null): RedisCluster|array|false;

/**

* @see \Redis::blmovem()

*/

public function blmovem(string $src, string $dst, string $wherefrom, string $whereto, float $timeout, ?array $options = null): RedisCluster|array|false;

/**

* Move an element from one list to another, blocking up to a timeout until an element is available.

*

* @see \Redis::blmove()

*

*/

public function blmove(string $src, string $dst, string $wherefrom, string $whereto, float $timeout): RedisCluster|string|false;

/**

* @see \Redis::bzPopMax()

*/

public function bzpopmax(string|array $key, string|int $timeout_or_key, mixed ...$extra_args): array;

/**

* @see \Redis::bzPopMin()

*/

public function bzpopmin(string|array $key, string|int $timeout_or_key, mixed ...$extra_args): array;

/**

* @see \Redis::bzmpop()

*/

public function bzmpop(float $timeout, array $keys, string $from, int $count = 1): RedisCluster|array|null|false;

/**

* @see \Redis::zmpop()

*/

public function zmpop(array $keys, string $from, int $count = 1): RedisCluster|array|null|false;

/**

* @see \Redis::blmpop()

*/

public function blmpop(float $timeout, array $keys, string $from, int $count = 1): RedisCluster|array|null|false;

/**

* @see \Redis::lmpop()

*/

public function lmpop(array $keys, string $from, int $count = 1): RedisCluster|array|null|false;

/**

* @see \Redis::clearLastError()

*/

public function clearlasterror(): bool;

/**

* @see \Redis::client()

*/

public function client(string|array $key_or_address, string $subcommand, ?string $arg = null): array|string|bool;

/**

* @see \Redis::close()

*/

public function close(): bool;

/**

* Execute Redis CLUSTER subcommands on the specified node.

*/

public function cluster(string|array $key_or_address, string $command, mixed ...$extra_args): mixed;

/**

* @see \Redis::command()

*/

public function command(mixed ...$extra_args): mixed;

/**

* @see \Redis::config()

*/

public function config(string|array $key_or_address, string $subcommand, mixed ...$extra_args): mixed;

/**

* @see \Redis::dbSize()

*/

public function dbsize(string|array $key_or_address): RedisCluster|int;

/**

* @see https://redis.io/commands/copy

*/

public function copy(string $src, string $dst, ?array $options = null): RedisCluster|bool;

/**

* @see \Redis::decr()

*/

public function decr(string $key, int $by = 1): RedisCluster|int|false;

/**

* @see \Redis::decrBy()

*/

public function decrby(string $key, int $value): RedisCluster|int|false;

/**

* Send a DECRBYFLOAT command for the given key.

*/

public function decrbyfloat(string $key, float $value): float;

/**

* @see \Redis::del()

*/

public function del(array|string $key, string ...$other_keys): RedisCluster|int|false;

/**

* Delete a key conditionally based on its value or hash digest.

*

* @param string $key The key to delete

* @param array|null $options An array with options to modify how DELEX works.

*

* @return RedisCluster|int|false Returns 1 if the key was deleted, 0 if it was not.

*/

public function delex(string $key, ?array $options = null): RedisCluster|int|false;

/**

* Delete a key if it's equal to the specified value. This command is

* specific to Valkey >= 9.0.

*

* @param string $key The key to delete

* @param mixed $value The value to compare against the key's value.

* @return RedisCluster|int|false Returns 1 if the key was deleted, 0 if it was not.

*/

public function delifeq(string $key, mixed $value): RedisCluster|int|false;

/**

* @see \Redis::discard()

*/

public function discard(): bool;

/**

* @see \Redis::dump()

*/

public function dump(string $key): RedisCluster|string|false;

/**

* @see \Redis::echo()

*/

public function echo(string|array $key_or_address, string $msg): RedisCluster|string|false;

/**

* @see \Redis::eval()

*/

public function eval(string $script, array $args = [], int $num_keys = 0): mixed;

/**

* @see \Redis::eval_ro()

*/

public function eval_ro(string $script, array $args = [], int $num_keys = 0): mixed;

/**

* @see \Redis::evalsha()

*/

public function evalsha(string $script_sha, array $args = [], int $num_keys = 0): mixed;

/**

* @see \Redis::evalsha_ro()

*/

public function evalsha_ro(string $script_sha, array $args = [], int $num_keys = 0): mixed;

/**

* @see \Redis::exec()

*/

public function exec(): array|false;

/**

* @see \Redis::exists()

*/

public function exists(mixed $key, mixed ...$other_keys): RedisCluster|int|bool;

/**

* @see \Redis::touch()

*/

public function touch(mixed $key, mixed ...$other_keys): RedisCluster|int|bool;

/**

* @see \Redis::expire()

*/

public function expire(string $key, int $timeout, ?string $mode = null): RedisCluster|bool;

/**

* @see \Redis::expireAt()

*/

public function expireat(string $key, int $timestamp, ?string $mode = null): RedisCluster|bool;

/**

* @see \Redis::expiretime()

*/

public function expiretime(string $key): RedisCluster|int|false;

/**

* @see \Redis::pexpiretime()

*/

public function pexpiretime(string $key): RedisCluster|int|false;

/**

* @see \Redis::flushAll()

*/

public function flushall(string|array $key_or_address, bool $async = false): RedisCluster|bool;

/**

* @see \Redis::flushDB()

*/

public function flushdb(string|array $key_or_address, bool $async = false): RedisCluster|bool;

/**

* @see \Redis::geoadd()

*/

public function geoadd(string $key, float $lng, float $lat, string $member, mixed ...$other_triples_and_options): RedisCluster|int|false;

/**

* @see \Redis::geodist()

*/

public function geodist(string $key, string $src, string $dest, ?string $unit = null): RedisCluster|float|false;

/**

* @see \Redis::geohash()

*/

public function geohash(string $key, string $member, string ...$other_members): RedisCluster|array|false;

/**

* @see \Redis::geopos()

*/

public function geopos(string $key, string $member, string ...$other_members): RedisCluster|array|false;

/**

* @see \Redis::georadius()

*/

public function georadius(string $key, float $lng, float $lat, float $radius, string $unit, array $options = []): mixed;

/**

* @see \Redis::georadius_ro()

*/

public function georadius_ro(string $key, float $lng, float $lat, float $radius, string $unit, array $options = []): mixed;

/**

* @see \Redis::georadiusbymember()

*/

public function georadiusbymember(string $key, string $member, float $radius, string $unit, array $options = []): mixed;

/**

* @see \Redis::georadiusbymember_ro()

*/

public function georadiusbymember_ro(string $key, string $member, float $radius, string $unit, array $options = []): mixed;

/**

* @see https://redis.io/commands/geosearch

*/

public function geosearch(string $key, array|string $position, array|int|float $shape, string $unit, array $options = []): RedisCluster|array;

/**

* @see https://redis.io/commands/geosearchstore

*/

public function geosearchstore(string $dst, string $src, array|string $position, array|int|float $shape, string $unit, array $options = []): RedisCluster|array|int|false;

/**

* @see \Redis::get()

*/

public function get(string $key): mixed;

/**

* @see \Redis::getDel()

*/

public function getdel(string $key): mixed;

/**

* @see \Redis::getWithMeta()

*/

public function getWithMeta(string $key): RedisCluster|array|false;

/**

* @see \Redis::getEx()

*/

public function getex(string $key, array $options = []): RedisCluster|string|false;

/**

* @see \Redis::getBit()

*/

public function getbit(string $key, int $value): RedisCluster|int|false;

/**

* @see \Redis::getLastError()

*/

public function getlasterror(): string|null;

/**

* @see \Redis::getMode()

*/

public function getmode(): int;

/**

* @see \Redis::getOption()

*/

public function getoption(int $option): mixed;

/**

* @see \Redis::getRange()

*/

public function getrange(string $key, int $start, int $end): RedisCluster|string|false;

/**

* @see \Redis::lcs()

*/

public function lcs(string $key1, string $key2, ?array $options = null): RedisCluster|string|array|int|false;

/**

* @see \Redis::getset()

*/

public function getset(string $key, mixed $value): RedisCluster|string|bool;

/**

* @see \Redis::getTransferredBytes()

*/

public function gettransferredbytes(): array|false;

/**

* @see \Redis::clearTransferredBytes()

*/

public function cleartransferredbytes(): void;

/**

* @see \Redis::hDel()

*/

public function hdel(string $key, string $member, string ...$other_members): RedisCluster|int|false;

/**

* @see \Redis::hExists()

*/

public function hexists(string $key, string $member): RedisCluster|bool;

/**

* @see \Redis::hGet()

*/

public function hget(string $key, string $member): mixed;

/**

* @see \Redis::hGetAll()

*/

public function hgetall(string $key): RedisCluster|array|false;

/**

* @see \Redis::hGetWithMeta()

*/

public function hgetWithMeta(string $key, string $member): mixed;

/**

* @see \Redis::hIncrBy()

*/

public function hincrby(string $key, string $member, int $value): RedisCluster|int|false;

/**

* @see \Redis::hIncrByFloat()

*/

public function hincrbyfloat(string $key, string $member, float $value): RedisCluster|float|false;

/**

* @see \Redis::hKeys()

*/

public function hkeys(string $key): RedisCluster|array|false;

/**

* @see \Redis::hLen()

*/

public function hlen(string $key): RedisCluster|int|false;

/**

* @see \Redis::hMget()

*/

public function hmget(string $key, array $keys): RedisCluster|array|false;

/**

* @see \Redis::hgetex()

*/

public function hgetex(string $key, array $fields, string|array|null $expiry = null): RedisCluster|array|false;

/**

* @see \Redis::hsetex()

*/

public function hsetex(string $key, array $fields, ?array $expiry = null): RedisCluster|int|false;

/**

* @see \Redis::hgetdel()

*/

public function hgetdel(string $key, array $fields): RedisCluster|array|false;

/**

* Note that unlike `\Redis::himport()` the hash is required for every

* operation, as it is what directs the command to the correct node. It is

* only sent to Redis for the 'SET' operation.

*

* @see \Redis::himport()

*/

public function himport(string $op, string $hash, ?string $fieldset = null, array $fields = []): RedisCluster|bool|int;

/**

* @see \Redis::hMset()

*/

public function hmset(string $key, array $key_values): RedisCluster|bool;

/**

* @see \Redis::hscan()

*/

public function hscan(string $key, null|int|string &$iterator, ?string $pattern = null, int $count = 0): array|bool;

/**

* @see \Redis::expiremember()

*/

public function expiremember(string $key, string $field, int $ttl, ?string $unit = null): RedisCluster|int|false;

/**

* @see \Redis::expirememberat()

*/

public function expirememberat(string $key, string $field, int $timestamp): RedisCluster|int|false;

/**

* @see https://redis.io/commands/hrandfield

*/

public function hrandfield(string $key, ?array $options = null): RedisCluster|string|array;

/**

* @see \Redis::hSet()

*/

public function hset(string $key, string $member, mixed $value): RedisCluster|int|false;

/**

* @see \Redis::hSetNx()

*/

public function hsetnx(string $key, string $member, mixed $value): RedisCluster|bool;

/**

* @see \Redis::hStrLen()

*/

public function hstrlen(string $key, string $field): RedisCluster|int|false;

/**

* @see \Redis::hexpire()

*/

public function hexpire(string $key, int $ttl, array $fields,

?string $mode = NULL): RedisCluster|array|false;

/**

* @see \Redis::hpexpire()

*/

public function hpexpire(string $key, int $ttl, array $fields,

?string $mode = NULL): RedisCluster|array|false;

/**

* @see \Redis::hexpireat()

*/

public function hexpireat(string $key, int $time, array $fields,

?string $mode = NULL): RedisCluster|array|false;

/**

* @see \Redis::hpexpireat()

*/

public function hpexpireat(string $key, int $mstime, array $fields,

?string $mode = NULL): RedisCluster|array|false;

/**

* @see \Redis::httl()

*/

public function httl(string $key, array $fields): RedisCluster|array|false;

/**

* @see \Redis::hpttl()

*/

public function hpttl(string $key, array $fields): RedisCluster|array|false;

/**

* @see \Redis::hexpiretime()

*/

public function hexpiretime(string $key, array $fields): RedisCluster|array|false;

/**

* @see \Redis::hpexpiretime()

*/

public function hpexpiretime(string $key, array $fields): RedisCluster|array|false;

/**

* @see \Redis::hpersist()

*/

public function hpersist(string $key, array $fields): RedisCluster|array|false;

/**

* @see \Redis::hVals()

*/

public function hvals(string $key): RedisCluster|array|false;

/**

* @see \Redis::incr()

*/

public function incr(string $key, int $by = 1): RedisCluster|int|false;

/**

* @see \Redis::incrBy()

*/

public function incrby(string $key, int $value): RedisCluster|int|false;

/**

* @see \Redis::incrByFloat()

*/

public function incrbyfloat(string $key, float $value): RedisCluster|float|false;

/**

* Retrieve information about a cluster node. If no sections are passed,

* Redis will return the default info fields. Alternatively you may pass a specific

* section you want returned (e.g. 'server', or 'memory') to receive only information pertaining

* to that section.

*

* If connected to Redis server >= 7.0.0 you may pass multiple optional sections.

*

* @see https://redis.io/commands/info/

*

* @param string|array $key_or_address Either a key name or array with host and port indicating

* which cluster node we want to send the command to.

* @param string ...$sections Optional sections you want the Redis server to return.

*

* @return RedisCluster|array|false

*/

public function info(string|array $key_or_address, string ...$sections): RedisCluster|array|false;

/**

* @see \Redis::keys()

*/

public function keys(string $pattern): RedisCluster|array|false;

/**

* @see \Redis::lastSave()

*/

public function lastsave(string|array $key_or_address): RedisCluster|int|false;

/**

* @see \Redis::lindex()

*/

public function lget(string $key, int $index): RedisCluster|string|bool;

/**

* @see \Redis::lindex()

*/

public function lindex(string $key, int $index): mixed;

/**

* @see \Redis::lInsert()

*/

public function linsert(string $key, string $pos, mixed $pivot, mixed $value): RedisCluster|int|false;

/**

* @see \Redis::lLen()

*/

public function llen(string $key): RedisCluster|int|bool;

/**

* @see \Redis::lPop()

*/

public function lpop(string $key, int $count = 0): RedisCluster|bool|string|array;

/**

* @see \Redis::lPos()

*/

public function lpos(string $key, mixed $value, ?array $options = null): RedisCluster|null|bool|int|array;

/**

* @see \Redis::lPush()

*/

public function lpush(string $key, mixed $value, mixed ...$other_values): RedisCluster|int|bool;

/**

* @see \Redis::lPushx()

*/

public function lpushx(string $key, mixed $value): RedisCluster|int|bool;

/**

* @see \Redis::lrange()

*/

public function lrange(string $key, int $start, int $end): RedisCluster|array|false;

/**

* @see \Redis::lrem()

*/

public function lrem(string $key, mixed $value, int $count = 0): RedisCluster|int|bool;

/**

* @see \Redis::lSet()

*/

public function lset(string $key, int $index, mixed $value): RedisCluster|bool;

/**

* @see \Redis::ltrim()

*/

public function ltrim(string $key, int $start, int $end): RedisCluster|bool;

/**

* @see \Redis::mget()

*/

public function mget(array $keys): RedisCluster|array|false;

/**

* @see \Redis::mset()

*/

public function mset(array $key_values): RedisCluster|bool;

/**

* @see \Redis::msetnx()

*/

public function msetnx(array $key_values): RedisCluster|array|false;

/**

* @see \Redis::msetex()

*/

public function msetex(array $key_vals, int|float|array|null $expiry = null): Redis|int|false;

/* We only support Redis::MULTI in RedisCluster but take the argument

so we can test MULTI..EXEC with RedisTest.php and in the event

we add pipeline support in the future. */

public function multi(int $value = Redis::MULTI): RedisCluster|bool;

/**

* @see \Redis::object()

*/

public function object(string $subcommand, string $key): RedisCluster|int|string|false;

/**

* @see \Redis::persist()

*/

public function persist(string $key): RedisCluster|bool;

/**

* @see \Redis::pexpire()

*/

public function pexpire(string $key, int $timeout, ?string $mode = null): RedisCluster|bool;

/**

* @see \Redis::pexpireAt()

*/

public function pexpireat(string $key, int $timestamp, ?string $mode = null): RedisCluster|bool;

/**

* @see \Redis::pfadd()

*/

public function pfadd(string $key, array $elements): RedisCluster|bool;

/**

* @see \Redis::pfcount()

*/

public function pfcount(string $key): RedisCluster|int|false;

/**

* @see \Redis::pfmerge()

*/

public function pfmerge(string $key, array $keys): RedisCluster|bool;

/**

* PING an instance in the Redis cluster.

*

* @see \Redis::ping()

*

* @param string|array $key_or_address Either a key name or a two-element array with host and

* port, informing RedisCluster which node to ping.

*

* @param string|null $message An optional message to send.

*

* @return mixed This method always returns `true` if no message was sent, and the message itself

* if one was.

*/

public function ping(string|array $key_or_address, ?string $message = null): mixed;

/**

* @see \Redis::psetex()

*/

public function psetex(string $key, int $timeout, string $value): RedisCluster|bool;

/**

* @see \Redis::psubscribe()

*/

public function psubscribe(array $patterns, callable $callback): void;

/**

* @see \Redis::pttl()

*/

public function pttl(string $key): RedisCluster|int|false;

/**

* @see \Redis::publish()

*/

public function publish(string $channel, string $message): RedisCluster|bool|int;

/**

* @see \Redis::pubsub()

*/

public function pubsub(string|array $key_or_address, string ...$values): mixed;

/**

* @see \Redis::punsubscribe()

*/

public function punsubscribe(string $pattern, string ...$other_patterns): bool|array;

/**

* @see \Redis::randomKey()

*/

public function randomkey(string|array $key_or_address): RedisCluster|bool|string;

/**

* @see \Redis::rawcommand()

*/

public function rawcommand(string|array $key_or_address, string $command, mixed ...$args): mixed;

/**

* @see \Redis::rename()

*/

public function rename(string $key_src, string $key_dst): RedisCluster|bool;

/**

* @see \Redis::renameNx()

*/

public function renamenx(string $key, string $newkey): RedisCluster|bool;

/**

* @see \Redis::restore()

*/

public function restore(string $key, int $timeout, string $value, ?array $options = null): RedisCluster|bool;

/**

* @see \Redis::role()

*/

public function role(string|array $key_or_address): mixed;

/**

* @see \Redis::rPop()

*/

public function rpop(string $key, int $count = 0): RedisCluster|bool|string|array;

/**

* @see \Redis::rpoplpush()

*/

public function rpoplpush(string $src, string $dst): RedisCluster|bool|string;

/**

* @see \Redis::rPush()

*/

public function rpush(string $key, mixed ...$elements): RedisCluster|int|false;

/**

* @see \Redis::rPushx()

*/

public function rpushx(string $key, string $value): RedisCluster|bool|int;

/**

* @see \Redis::sAdd()

*/

public function sadd(string $key, mixed $value, mixed ...$other_values): RedisCluster|int|false;

/**

* @see \Redis::sAddArray()

*/

public function saddarray(string $key, array $values): RedisCluster|bool|int;

/**

* @see \Redis::save()

*/

public function save(string|array $key_or_address): RedisCluster|bool;

/**

* @see \Redis::scan()

*/

public function scan(null|int|string &$iterator, string|array $key_or_address, ?string $pattern = null, int $count = 0): bool|array;

/**

* @see \Redis::scard()

*/

public function scard(string $key): RedisCluster|int|false;

/**

* @see \Redis::script()

*/

public function script(string|array $key_or_address, mixed ...$args): mixed;

/**

* @see \Redis::sDiff()

*/

public function sdiff(string $key, string ...$other_keys): RedisCluster|array|false;

/**

* @see \Redis::sDiffStore()

*/

public function sdiffstore(string $dst, string $key, string ...$other_keys): RedisCluster|int|false;

/**

* @see https://redis.io/commands/set

*/

public function set(string $key, mixed $value, mixed $options = null): RedisCluster|string|bool;

/**

* @see \Redis::setBit()

*/

public function setbit(string $key, int $offset, bool $onoff): RedisCluster|int|false;

/**

* @see \Redis::setex()

*/

public function setex(string $key, int $expire, mixed $value): RedisCluster|bool;

/**