From f3fafc749ff8e8536e46a450110872ce19688ddd Mon Sep 17 00:00:00 2001
From: Nicolas Grekas <nicolas.grekas@gmail.com>
Date: Mon, 6 Feb 2023 09:05:09 +0100
Subject: [PATCH] [Cache] Fix Redis proxies

---
 .../Cache/Tests/Traits/RedisProxiesTest.php   |  14 +-
 .../Component/Cache/Traits/Redis5Proxy.php    | 478 ++++++++--------
 .../Component/Cache/Traits/Redis6Proxy.php    | 515 +++++++++---------
 .../Cache/Traits/RedisCluster5Proxy.php       | 380 ++++++-------
 .../Cache/Traits/RedisCluster6Proxy.php       | 444 +++++++--------
 5 files changed, 928 insertions(+), 903 deletions(-)

diff --git a/src/Symfony/Component/Cache/Tests/Traits/RedisProxiesTest.php b/src/Symfony/Component/Cache/Tests/Traits/RedisProxiesTest.php
index 27fabf700af8a..954009635006e 100644
--- a/src/Symfony/Component/Cache/Tests/Traits/RedisProxiesTest.php
+++ b/src/Symfony/Component/Cache/Tests/Traits/RedisProxiesTest.php
@@ -34,10 +34,15 @@ public function testRedis5Proxy($class)
             if ('reset' === $method->name || method_exists(LazyProxyTrait::class, $method->name)) {
                 continue;
             }
+            $args = [];
+            foreach ($method->getParameters() as $param) {
+                $args[] = ($param->isVariadic() ? '...' : '').'$'.$param->name;
+            }
+            $args = implode(', ', $args);
             $return = $method->getReturnType() instanceof \ReflectionNamedType && 'void' === (string) $method->getReturnType() ? '' : 'return ';
             $methods[] = "\n    ".ProxyHelper::exportSignature($method, false)."\n".<<<EOPHP
                 {
-                    {$return}\$this->lazyObjectReal->{$method->name}(...\\func_get_args());
+                    {$return}\$this->lazyObjectReal->{$method->name}({$args});
                 }
 
             EOPHP;
@@ -71,10 +76,15 @@ public function testRedis6Proxy($class, $stub)
             if ('reset' === $method->name || method_exists(LazyProxyTrait::class, $method->name)) {
                 continue;
             }
+            $args = [];
+            foreach ($method->getParameters() as $param) {
+                $args[] = ($param->isVariadic() ? '...' : '').'$'.$param->name;
+            }
+            $args = implode(', ', $args);
             $return = $method->getReturnType() instanceof \ReflectionNamedType && 'void' === (string) $method->getReturnType() ? '' : 'return ';
             $methods[] = "\n    ".ProxyHelper::exportSignature($method, false)."\n".<<<EOPHP
                 {
-                    {$return}\$this->lazyObjectReal->{$method->name}(...\\func_get_args());
+                    {$return}\$this->lazyObjectReal->{$method->name}({$args});
                 }
 
             EOPHP;
diff --git a/src/Symfony/Component/Cache/Traits/Redis5Proxy.php b/src/Symfony/Component/Cache/Traits/Redis5Proxy.php
index bcfe8bc8d3288..87022036c1c31 100644
--- a/src/Symfony/Component/Cache/Traits/Redis5Proxy.php
+++ b/src/Symfony/Component/Cache/Traits/Redis5Proxy.php
@@ -36,1196 +36,1196 @@ class Redis5Proxy extends \Redis implements ResetInterface, LazyObjectInterface
 
     public function __construct()
     {
-        return $this->lazyObjectReal->__construct(...\func_get_args());
+        return $this->lazyObjectReal->__construct();
     }
 
     public function _prefix($key)
     {
-        return $this->lazyObjectReal->_prefix(...\func_get_args());
+        return $this->lazyObjectReal->_prefix($key);
     }
 
     public function _serialize($value)
     {
-        return $this->lazyObjectReal->_serialize(...\func_get_args());
+        return $this->lazyObjectReal->_serialize($value);
     }
 
     public function _unserialize($value)
     {
-        return $this->lazyObjectReal->_unserialize(...\func_get_args());
+        return $this->lazyObjectReal->_unserialize($value);
     }
 
     public function _pack($value)
     {
-        return $this->lazyObjectReal->_pack(...\func_get_args());
+        return $this->lazyObjectReal->_pack($value);
     }
 
     public function _unpack($value)
     {
-        return $this->lazyObjectReal->_unpack(...\func_get_args());
+        return $this->lazyObjectReal->_unpack($value);
     }
 
     public function _compress($value)
     {
-        return $this->lazyObjectReal->_compress(...\func_get_args());
+        return $this->lazyObjectReal->_compress($value);
     }
 
     public function _uncompress($value)
     {
-        return $this->lazyObjectReal->_uncompress(...\func_get_args());
+        return $this->lazyObjectReal->_uncompress($value);
     }
 
     public function acl($subcmd, ...$args)
     {
-        return $this->lazyObjectReal->acl(...\func_get_args());
+        return $this->lazyObjectReal->acl($subcmd, ...$args);
     }
 
     public function append($key, $value)
     {
-        return $this->lazyObjectReal->append(...\func_get_args());
+        return $this->lazyObjectReal->append($key, $value);
     }
 
     public function auth($auth)
     {
-        return $this->lazyObjectReal->auth(...\func_get_args());
+        return $this->lazyObjectReal->auth($auth);
     }
 
     public function bgSave()
     {
-        return $this->lazyObjectReal->bgSave(...\func_get_args());
+        return $this->lazyObjectReal->bgSave();
     }
 
     public function bgrewriteaof()
     {
-        return $this->lazyObjectReal->bgrewriteaof(...\func_get_args());
+        return $this->lazyObjectReal->bgrewriteaof();
     }
 
     public function bitcount($key)
     {
-        return $this->lazyObjectReal->bitcount(...\func_get_args());
+        return $this->lazyObjectReal->bitcount($key);
     }
 
     public function bitop($operation, $ret_key, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->bitop(...\func_get_args());
+        return $this->lazyObjectReal->bitop($operation, $ret_key, $key, ...$other_keys);
     }
 
     public function bitpos($key, $bit, $start = null, $end = null)
     {
-        return $this->lazyObjectReal->bitpos(...\func_get_args());
+        return $this->lazyObjectReal->bitpos($key, $bit, $start, $end);
     }
 
     public function blPop($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->blPop(...\func_get_args());
+        return $this->lazyObjectReal->blPop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brPop($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->brPop(...\func_get_args());
+        return $this->lazyObjectReal->brPop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brpoplpush($src, $dst, $timeout)
     {
-        return $this->lazyObjectReal->brpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->brpoplpush($src, $dst, $timeout);
     }
 
     public function bzPopMax($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->bzPopMax(...\func_get_args());
+        return $this->lazyObjectReal->bzPopMax($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzPopMin($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->bzPopMin(...\func_get_args());
+        return $this->lazyObjectReal->bzPopMin($key, $timeout_or_key, ...$extra_args);
     }
 
     public function clearLastError()
     {
-        return $this->lazyObjectReal->clearLastError(...\func_get_args());
+        return $this->lazyObjectReal->clearLastError();
     }
 
     public function client($cmd, ...$args)
     {
-        return $this->lazyObjectReal->client(...\func_get_args());
+        return $this->lazyObjectReal->client($cmd, ...$args);
     }
 
     public function close()
     {
-        return $this->lazyObjectReal->close(...\func_get_args());
+        return $this->lazyObjectReal->close();
     }
 
     public function command(...$args)
     {
-        return $this->lazyObjectReal->command(...\func_get_args());
+        return $this->lazyObjectReal->command(...$args);
     }
 
     public function config($cmd, $key, $value = null)
     {
-        return $this->lazyObjectReal->config(...\func_get_args());
+        return $this->lazyObjectReal->config($cmd, $key, $value);
     }
 
     public function connect($host, $port = null, $timeout = null, $retry_interval = null)
     {
-        return $this->lazyObjectReal->connect(...\func_get_args());
+        return $this->lazyObjectReal->connect($host, $port, $timeout, $retry_interval);
     }
 
     public function dbSize()
     {
-        return $this->lazyObjectReal->dbSize(...\func_get_args());
+        return $this->lazyObjectReal->dbSize();
     }
 
     public function debug($key)
     {
-        return $this->lazyObjectReal->debug(...\func_get_args());
+        return $this->lazyObjectReal->debug($key);
     }
 
     public function decr($key)
     {
-        return $this->lazyObjectReal->decr(...\func_get_args());
+        return $this->lazyObjectReal->decr($key);
     }
 
     public function decrBy($key, $value)
     {
-        return $this->lazyObjectReal->decrBy(...\func_get_args());
+        return $this->lazyObjectReal->decrBy($key, $value);
     }
 
     public function del($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->del(...\func_get_args());
+        return $this->lazyObjectReal->del($key, ...$other_keys);
     }
 
     public function discard()
     {
-        return $this->lazyObjectReal->discard(...\func_get_args());
+        return $this->lazyObjectReal->discard();
     }
 
     public function dump($key)
     {
-        return $this->lazyObjectReal->dump(...\func_get_args());
+        return $this->lazyObjectReal->dump($key);
     }
 
     public function echo($msg)
     {
-        return $this->lazyObjectReal->echo(...\func_get_args());
+        return $this->lazyObjectReal->echo($msg);
     }
 
     public function eval($script, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->eval(...\func_get_args());
+        return $this->lazyObjectReal->eval($script, $args, $num_keys);
     }
 
     public function evalsha($script_sha, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->evalsha(...\func_get_args());
+        return $this->lazyObjectReal->evalsha($script_sha, $args, $num_keys);
     }
 
     public function exec()
     {
-        return $this->lazyObjectReal->exec(...\func_get_args());
+        return $this->lazyObjectReal->exec();
     }
 
     public function exists($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->exists(...\func_get_args());
+        return $this->lazyObjectReal->exists($key, ...$other_keys);
     }
 
     public function expire($key, $timeout)
     {
-        return $this->lazyObjectReal->expire(...\func_get_args());
+        return $this->lazyObjectReal->expire($key, $timeout);
     }
 
     public function expireAt($key, $timestamp)
     {
-        return $this->lazyObjectReal->expireAt(...\func_get_args());
+        return $this->lazyObjectReal->expireAt($key, $timestamp);
     }
 
     public function flushAll($async = null)
     {
-        return $this->lazyObjectReal->flushAll(...\func_get_args());
+        return $this->lazyObjectReal->flushAll($async);
     }
 
     public function flushDB($async = null)
     {
-        return $this->lazyObjectReal->flushDB(...\func_get_args());
+        return $this->lazyObjectReal->flushDB($async);
     }
 
     public function geoadd($key, $lng, $lat, $member, ...$other_triples)
     {
-        return $this->lazyObjectReal->geoadd(...\func_get_args());
+        return $this->lazyObjectReal->geoadd($key, $lng, $lat, $member, ...$other_triples);
     }
 
     public function geodist($key, $src, $dst, $unit = null)
     {
-        return $this->lazyObjectReal->geodist(...\func_get_args());
+        return $this->lazyObjectReal->geodist($key, $src, $dst, $unit);
     }
 
     public function geohash($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->geohash(...\func_get_args());
+        return $this->lazyObjectReal->geohash($key, $member, ...$other_members);
     }
 
     public function geopos($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->geopos(...\func_get_args());
+        return $this->lazyObjectReal->geopos($key, $member, ...$other_members);
     }
 
     public function georadius($key, $lng, $lan, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadius(...\func_get_args());
+        return $this->lazyObjectReal->georadius($key, $lng, $lan, $radius, $unit, $opts);
     }
 
     public function georadius_ro($key, $lng, $lan, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadius_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadius_ro($key, $lng, $lan, $radius, $unit, $opts);
     }
 
     public function georadiusbymember($key, $member, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadiusbymember(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember($key, $member, $radius, $unit, $opts);
     }
 
     public function georadiusbymember_ro($key, $member, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadiusbymember_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember_ro($key, $member, $radius, $unit, $opts);
     }
 
     public function get($key)
     {
-        return $this->lazyObjectReal->get(...\func_get_args());
+        return $this->lazyObjectReal->get($key);
     }
 
     public function getAuth()
     {
-        return $this->lazyObjectReal->getAuth(...\func_get_args());
+        return $this->lazyObjectReal->getAuth();
     }
 
     public function getBit($key, $offset)
     {
-        return $this->lazyObjectReal->getBit(...\func_get_args());
+        return $this->lazyObjectReal->getBit($key, $offset);
     }
 
     public function getDBNum()
     {
-        return $this->lazyObjectReal->getDBNum(...\func_get_args());
+        return $this->lazyObjectReal->getDBNum();
     }
 
     public function getHost()
     {
-        return $this->lazyObjectReal->getHost(...\func_get_args());
+        return $this->lazyObjectReal->getHost();
     }
 
     public function getLastError()
     {
-        return $this->lazyObjectReal->getLastError(...\func_get_args());
+        return $this->lazyObjectReal->getLastError();
     }
 
     public function getMode()
     {
-        return $this->lazyObjectReal->getMode(...\func_get_args());
+        return $this->lazyObjectReal->getMode();
     }
 
     public function getOption($option)
     {
-        return $this->lazyObjectReal->getOption(...\func_get_args());
+        return $this->lazyObjectReal->getOption($option);
     }
 
     public function getPersistentID()
     {
-        return $this->lazyObjectReal->getPersistentID(...\func_get_args());
+        return $this->lazyObjectReal->getPersistentID();
     }
 
     public function getPort()
     {
-        return $this->lazyObjectReal->getPort(...\func_get_args());
+        return $this->lazyObjectReal->getPort();
     }
 
     public function getRange($key, $start, $end)
     {
-        return $this->lazyObjectReal->getRange(...\func_get_args());
+        return $this->lazyObjectReal->getRange($key, $start, $end);
     }
 
     public function getReadTimeout()
     {
-        return $this->lazyObjectReal->getReadTimeout(...\func_get_args());
+        return $this->lazyObjectReal->getReadTimeout();
     }
 
     public function getSet($key, $value)
     {
-        return $this->lazyObjectReal->getSet(...\func_get_args());
+        return $this->lazyObjectReal->getSet($key, $value);
     }
 
     public function getTimeout()
     {
-        return $this->lazyObjectReal->getTimeout(...\func_get_args());
+        return $this->lazyObjectReal->getTimeout();
     }
 
     public function hDel($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->hDel(...\func_get_args());
+        return $this->lazyObjectReal->hDel($key, $member, ...$other_members);
     }
 
     public function hExists($key, $member)
     {
-        return $this->lazyObjectReal->hExists(...\func_get_args());
+        return $this->lazyObjectReal->hExists($key, $member);
     }
 
     public function hGet($key, $member)
     {
-        return $this->lazyObjectReal->hGet(...\func_get_args());
+        return $this->lazyObjectReal->hGet($key, $member);
     }
 
     public function hGetAll($key)
     {
-        return $this->lazyObjectReal->hGetAll(...\func_get_args());
+        return $this->lazyObjectReal->hGetAll($key);
     }
 
     public function hIncrBy($key, $member, $value)
     {
-        return $this->lazyObjectReal->hIncrBy(...\func_get_args());
+        return $this->lazyObjectReal->hIncrBy($key, $member, $value);
     }
 
     public function hIncrByFloat($key, $member, $value)
     {
-        return $this->lazyObjectReal->hIncrByFloat(...\func_get_args());
+        return $this->lazyObjectReal->hIncrByFloat($key, $member, $value);
     }
 
     public function hKeys($key)
     {
-        return $this->lazyObjectReal->hKeys(...\func_get_args());
+        return $this->lazyObjectReal->hKeys($key);
     }
 
     public function hLen($key)
     {
-        return $this->lazyObjectReal->hLen(...\func_get_args());
+        return $this->lazyObjectReal->hLen($key);
     }
 
     public function hMget($key, $keys)
     {
-        return $this->lazyObjectReal->hMget(...\func_get_args());
+        return $this->lazyObjectReal->hMget($key, $keys);
     }
 
     public function hMset($key, $pairs)
     {
-        return $this->lazyObjectReal->hMset(...\func_get_args());
+        return $this->lazyObjectReal->hMset($key, $pairs);
     }
 
     public function hSet($key, $member, $value)
     {
-        return $this->lazyObjectReal->hSet(...\func_get_args());
+        return $this->lazyObjectReal->hSet($key, $member, $value);
     }
 
     public function hSetNx($key, $member, $value)
     {
-        return $this->lazyObjectReal->hSetNx(...\func_get_args());
+        return $this->lazyObjectReal->hSetNx($key, $member, $value);
     }
 
     public function hStrLen($key, $member)
     {
-        return $this->lazyObjectReal->hStrLen(...\func_get_args());
+        return $this->lazyObjectReal->hStrLen($key, $member);
     }
 
     public function hVals($key)
     {
-        return $this->lazyObjectReal->hVals(...\func_get_args());
+        return $this->lazyObjectReal->hVals($key);
     }
 
     public function hscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->hscan(...\func_get_args());
+        return $this->lazyObjectReal->hscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function incr($key)
     {
-        return $this->lazyObjectReal->incr(...\func_get_args());
+        return $this->lazyObjectReal->incr($key);
     }
 
     public function incrBy($key, $value)
     {
-        return $this->lazyObjectReal->incrBy(...\func_get_args());
+        return $this->lazyObjectReal->incrBy($key, $value);
     }
 
     public function incrByFloat($key, $value)
     {
-        return $this->lazyObjectReal->incrByFloat(...\func_get_args());
+        return $this->lazyObjectReal->incrByFloat($key, $value);
     }
 
     public function info($option = null)
     {
-        return $this->lazyObjectReal->info(...\func_get_args());
+        return $this->lazyObjectReal->info($option);
     }
 
     public function isConnected()
     {
-        return $this->lazyObjectReal->isConnected(...\func_get_args());
+        return $this->lazyObjectReal->isConnected();
     }
 
     public function keys($pattern)
     {
-        return $this->lazyObjectReal->keys(...\func_get_args());
+        return $this->lazyObjectReal->keys($pattern);
     }
 
     public function lInsert($key, $position, $pivot, $value)
     {
-        return $this->lazyObjectReal->lInsert(...\func_get_args());
+        return $this->lazyObjectReal->lInsert($key, $position, $pivot, $value);
     }
 
     public function lLen($key)
     {
-        return $this->lazyObjectReal->lLen(...\func_get_args());
+        return $this->lazyObjectReal->lLen($key);
     }
 
     public function lPop($key)
     {
-        return $this->lazyObjectReal->lPop(...\func_get_args());
+        return $this->lazyObjectReal->lPop($key);
     }
 
     public function lPush($key, $value)
     {
-        return $this->lazyObjectReal->lPush(...\func_get_args());
+        return $this->lazyObjectReal->lPush($key, $value);
     }
 
     public function lPushx($key, $value)
     {
-        return $this->lazyObjectReal->lPushx(...\func_get_args());
+        return $this->lazyObjectReal->lPushx($key, $value);
     }
 
     public function lSet($key, $index, $value)
     {
-        return $this->lazyObjectReal->lSet(...\func_get_args());
+        return $this->lazyObjectReal->lSet($key, $index, $value);
     }
 
     public function lastSave()
     {
-        return $this->lazyObjectReal->lastSave(...\func_get_args());
+        return $this->lazyObjectReal->lastSave();
     }
 
     public function lindex($key, $index)
     {
-        return $this->lazyObjectReal->lindex(...\func_get_args());
+        return $this->lazyObjectReal->lindex($key, $index);
     }
 
     public function lrange($key, $start, $end)
     {
-        return $this->lazyObjectReal->lrange(...\func_get_args());
+        return $this->lazyObjectReal->lrange($key, $start, $end);
     }
 
     public function lrem($key, $value, $count)
     {
-        return $this->lazyObjectReal->lrem(...\func_get_args());
+        return $this->lazyObjectReal->lrem($key, $value, $count);
     }
 
     public function ltrim($key, $start, $stop)
     {
-        return $this->lazyObjectReal->ltrim(...\func_get_args());
+        return $this->lazyObjectReal->ltrim($key, $start, $stop);
     }
 
     public function mget($keys)
     {
-        return $this->lazyObjectReal->mget(...\func_get_args());
+        return $this->lazyObjectReal->mget($keys);
     }
 
     public function migrate($host, $port, $key, $db, $timeout, $copy = null, $replace = null)
     {
-        return $this->lazyObjectReal->migrate(...\func_get_args());
+        return $this->lazyObjectReal->migrate($host, $port, $key, $db, $timeout, $copy, $replace);
     }
 
     public function move($key, $dbindex)
     {
-        return $this->lazyObjectReal->move(...\func_get_args());
+        return $this->lazyObjectReal->move($key, $dbindex);
     }
 
     public function mset($pairs)
     {
-        return $this->lazyObjectReal->mset(...\func_get_args());
+        return $this->lazyObjectReal->mset($pairs);
     }
 
     public function msetnx($pairs)
     {
-        return $this->lazyObjectReal->msetnx(...\func_get_args());
+        return $this->lazyObjectReal->msetnx($pairs);
     }
 
     public function multi($mode = null)
     {
-        return $this->lazyObjectReal->multi(...\func_get_args());
+        return $this->lazyObjectReal->multi($mode);
     }
 
     public function object($field, $key)
     {
-        return $this->lazyObjectReal->object(...\func_get_args());
+        return $this->lazyObjectReal->object($field, $key);
     }
 
     public function pconnect($host, $port = null, $timeout = null)
     {
-        return $this->lazyObjectReal->pconnect(...\func_get_args());
+        return $this->lazyObjectReal->pconnect($host, $port, $timeout);
     }
 
     public function persist($key)
     {
-        return $this->lazyObjectReal->persist(...\func_get_args());
+        return $this->lazyObjectReal->persist($key);
     }
 
     public function pexpire($key, $timestamp)
     {
-        return $this->lazyObjectReal->pexpire(...\func_get_args());
+        return $this->lazyObjectReal->pexpire($key, $timestamp);
     }
 
     public function pexpireAt($key, $timestamp)
     {
-        return $this->lazyObjectReal->pexpireAt(...\func_get_args());
+        return $this->lazyObjectReal->pexpireAt($key, $timestamp);
     }
 
     public function pfadd($key, $elements)
     {
-        return $this->lazyObjectReal->pfadd(...\func_get_args());
+        return $this->lazyObjectReal->pfadd($key, $elements);
     }
 
     public function pfcount($key)
     {
-        return $this->lazyObjectReal->pfcount(...\func_get_args());
+        return $this->lazyObjectReal->pfcount($key);
     }
 
     public function pfmerge($dstkey, $keys)
     {
-        return $this->lazyObjectReal->pfmerge(...\func_get_args());
+        return $this->lazyObjectReal->pfmerge($dstkey, $keys);
     }
 
     public function ping()
     {
-        return $this->lazyObjectReal->ping(...\func_get_args());
+        return $this->lazyObjectReal->ping();
     }
 
     public function pipeline()
     {
-        return $this->lazyObjectReal->pipeline(...\func_get_args());
+        return $this->lazyObjectReal->pipeline();
     }
 
     public function psetex($key, $expire, $value)
     {
-        return $this->lazyObjectReal->psetex(...\func_get_args());
+        return $this->lazyObjectReal->psetex($key, $expire, $value);
     }
 
     public function psubscribe($patterns, $callback)
     {
-        return $this->lazyObjectReal->psubscribe(...\func_get_args());
+        return $this->lazyObjectReal->psubscribe($patterns, $callback);
     }
 
     public function pttl($key)
     {
-        return $this->lazyObjectReal->pttl(...\func_get_args());
+        return $this->lazyObjectReal->pttl($key);
     }
 
     public function publish($channel, $message)
     {
-        return $this->lazyObjectReal->publish(...\func_get_args());
+        return $this->lazyObjectReal->publish($channel, $message);
     }
 
     public function pubsub($cmd, ...$args)
     {
-        return $this->lazyObjectReal->pubsub(...\func_get_args());
+        return $this->lazyObjectReal->pubsub($cmd, ...$args);
     }
 
     public function punsubscribe($pattern, ...$other_patterns)
     {
-        return $this->lazyObjectReal->punsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->punsubscribe($pattern, ...$other_patterns);
     }
 
     public function rPop($key)
     {
-        return $this->lazyObjectReal->rPop(...\func_get_args());
+        return $this->lazyObjectReal->rPop($key);
     }
 
     public function rPush($key, $value)
     {
-        return $this->lazyObjectReal->rPush(...\func_get_args());
+        return $this->lazyObjectReal->rPush($key, $value);
     }
 
     public function rPushx($key, $value)
     {
-        return $this->lazyObjectReal->rPushx(...\func_get_args());
+        return $this->lazyObjectReal->rPushx($key, $value);
     }
 
     public function randomKey()
     {
-        return $this->lazyObjectReal->randomKey(...\func_get_args());
+        return $this->lazyObjectReal->randomKey();
     }
 
     public function rawcommand($cmd, ...$args)
     {
-        return $this->lazyObjectReal->rawcommand(...\func_get_args());
+        return $this->lazyObjectReal->rawcommand($cmd, ...$args);
     }
 
     public function rename($key, $newkey)
     {
-        return $this->lazyObjectReal->rename(...\func_get_args());
+        return $this->lazyObjectReal->rename($key, $newkey);
     }
 
     public function renameNx($key, $newkey)
     {
-        return $this->lazyObjectReal->renameNx(...\func_get_args());
+        return $this->lazyObjectReal->renameNx($key, $newkey);
     }
 
     public function restore($ttl, $key, $value)
     {
-        return $this->lazyObjectReal->restore(...\func_get_args());
+        return $this->lazyObjectReal->restore($ttl, $key, $value);
     }
 
     public function role()
     {
-        return $this->lazyObjectReal->role(...\func_get_args());
+        return $this->lazyObjectReal->role();
     }
 
     public function rpoplpush($src, $dst)
     {
-        return $this->lazyObjectReal->rpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->rpoplpush($src, $dst);
     }
 
     public function sAdd($key, $value)
     {
-        return $this->lazyObjectReal->sAdd(...\func_get_args());
+        return $this->lazyObjectReal->sAdd($key, $value);
     }
 
     public function sAddArray($key, $options)
     {
-        return $this->lazyObjectReal->sAddArray(...\func_get_args());
+        return $this->lazyObjectReal->sAddArray($key, $options);
     }
 
     public function sDiff($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sDiff(...\func_get_args());
+        return $this->lazyObjectReal->sDiff($key, ...$other_keys);
     }
 
     public function sDiffStore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sDiffStore(...\func_get_args());
+        return $this->lazyObjectReal->sDiffStore($dst, $key, ...$other_keys);
     }
 
     public function sInter($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sInter(...\func_get_args());
+        return $this->lazyObjectReal->sInter($key, ...$other_keys);
     }
 
     public function sInterStore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sInterStore(...\func_get_args());
+        return $this->lazyObjectReal->sInterStore($dst, $key, ...$other_keys);
     }
 
     public function sMembers($key)
     {
-        return $this->lazyObjectReal->sMembers(...\func_get_args());
+        return $this->lazyObjectReal->sMembers($key);
     }
 
     public function sMisMember($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->sMisMember(...\func_get_args());
+        return $this->lazyObjectReal->sMisMember($key, $member, ...$other_members);
     }
 
     public function sMove($src, $dst, $value)
     {
-        return $this->lazyObjectReal->sMove(...\func_get_args());
+        return $this->lazyObjectReal->sMove($src, $dst, $value);
     }
 
     public function sPop($key)
     {
-        return $this->lazyObjectReal->sPop(...\func_get_args());
+        return $this->lazyObjectReal->sPop($key);
     }
 
     public function sRandMember($key, $count = null)
     {
-        return $this->lazyObjectReal->sRandMember(...\func_get_args());
+        return $this->lazyObjectReal->sRandMember($key, $count);
     }
 
     public function sUnion($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sUnion(...\func_get_args());
+        return $this->lazyObjectReal->sUnion($key, ...$other_keys);
     }
 
     public function sUnionStore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sUnionStore(...\func_get_args());
+        return $this->lazyObjectReal->sUnionStore($dst, $key, ...$other_keys);
     }
 
     public function save()
     {
-        return $this->lazyObjectReal->save(...\func_get_args());
+        return $this->lazyObjectReal->save();
     }
 
     public function scan(&$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->scan(...\func_get_args());
+        return $this->lazyObjectReal->scan($i_iterator, $str_pattern, $i_count);
     }
 
     public function scard($key)
     {
-        return $this->lazyObjectReal->scard(...\func_get_args());
+        return $this->lazyObjectReal->scard($key);
     }
 
     public function script($cmd, ...$args)
     {
-        return $this->lazyObjectReal->script(...\func_get_args());
+        return $this->lazyObjectReal->script($cmd, ...$args);
     }
 
     public function select($dbindex)
     {
-        return $this->lazyObjectReal->select(...\func_get_args());
+        return $this->lazyObjectReal->select($dbindex);
     }
 
     public function set($key, $value, $opts = null)
     {
-        return $this->lazyObjectReal->set(...\func_get_args());
+        return $this->lazyObjectReal->set($key, $value, $opts);
     }
 
     public function setBit($key, $offset, $value)
     {
-        return $this->lazyObjectReal->setBit(...\func_get_args());
+        return $this->lazyObjectReal->setBit($key, $offset, $value);
     }
 
     public function setOption($option, $value)
     {
-        return $this->lazyObjectReal->setOption(...\func_get_args());
+        return $this->lazyObjectReal->setOption($option, $value);
     }
 
     public function setRange($key, $offset, $value)
     {
-        return $this->lazyObjectReal->setRange(...\func_get_args());
+        return $this->lazyObjectReal->setRange($key, $offset, $value);
     }
 
     public function setex($key, $expire, $value)
     {
-        return $this->lazyObjectReal->setex(...\func_get_args());
+        return $this->lazyObjectReal->setex($key, $expire, $value);
     }
 
     public function setnx($key, $value)
     {
-        return $this->lazyObjectReal->setnx(...\func_get_args());
+        return $this->lazyObjectReal->setnx($key, $value);
     }
 
     public function sismember($key, $value)
     {
-        return $this->lazyObjectReal->sismember(...\func_get_args());
+        return $this->lazyObjectReal->sismember($key, $value);
     }
 
     public function slaveof($host = null, $port = null)
     {
-        return $this->lazyObjectReal->slaveof(...\func_get_args());
+        return $this->lazyObjectReal->slaveof($host, $port);
     }
 
     public function slowlog($arg, $option = null)
     {
-        return $this->lazyObjectReal->slowlog(...\func_get_args());
+        return $this->lazyObjectReal->slowlog($arg, $option);
     }
 
     public function sort($key, $options = null)
     {
-        return $this->lazyObjectReal->sort(...\func_get_args());
+        return $this->lazyObjectReal->sort($key, $options);
     }
 
     public function sortAsc($key, $pattern = null, $get = null, $start = null, $end = null, $getList = null)
     {
-        return $this->lazyObjectReal->sortAsc(...\func_get_args());
+        return $this->lazyObjectReal->sortAsc($key, $pattern, $get, $start, $end, $getList);
     }
 
     public function sortAscAlpha($key, $pattern = null, $get = null, $start = null, $end = null, $getList = null)
     {
-        return $this->lazyObjectReal->sortAscAlpha(...\func_get_args());
+        return $this->lazyObjectReal->sortAscAlpha($key, $pattern, $get, $start, $end, $getList);
     }
 
     public function sortDesc($key, $pattern = null, $get = null, $start = null, $end = null, $getList = null)
     {
-        return $this->lazyObjectReal->sortDesc(...\func_get_args());
+        return $this->lazyObjectReal->sortDesc($key, $pattern, $get, $start, $end, $getList);
     }
 
     public function sortDescAlpha($key, $pattern = null, $get = null, $start = null, $end = null, $getList = null)
     {
-        return $this->lazyObjectReal->sortDescAlpha(...\func_get_args());
+        return $this->lazyObjectReal->sortDescAlpha($key, $pattern, $get, $start, $end, $getList);
     }
 
     public function srem($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->srem(...\func_get_args());
+        return $this->lazyObjectReal->srem($key, $member, ...$other_members);
     }
 
     public function sscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->sscan(...\func_get_args());
+        return $this->lazyObjectReal->sscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function strlen($key)
     {
-        return $this->lazyObjectReal->strlen(...\func_get_args());
+        return $this->lazyObjectReal->strlen($key);
     }
 
     public function subscribe($channels, $callback)
     {
-        return $this->lazyObjectReal->subscribe(...\func_get_args());
+        return $this->lazyObjectReal->subscribe($channels, $callback);
     }
 
     public function swapdb($srcdb, $dstdb)
     {
-        return $this->lazyObjectReal->swapdb(...\func_get_args());
+        return $this->lazyObjectReal->swapdb($srcdb, $dstdb);
     }
 
     public function time()
     {
-        return $this->lazyObjectReal->time(...\func_get_args());
+        return $this->lazyObjectReal->time();
     }
 
     public function ttl($key)
     {
-        return $this->lazyObjectReal->ttl(...\func_get_args());
+        return $this->lazyObjectReal->ttl($key);
     }
 
     public function type($key)
     {
-        return $this->lazyObjectReal->type(...\func_get_args());
+        return $this->lazyObjectReal->type($key);
     }
 
     public function unlink($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->unlink(...\func_get_args());
+        return $this->lazyObjectReal->unlink($key, ...$other_keys);
     }
 
     public function unsubscribe($channel, ...$other_channels)
     {
-        return $this->lazyObjectReal->unsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->unsubscribe($channel, ...$other_channels);
     }
 
     public function unwatch()
     {
-        return $this->lazyObjectReal->unwatch(...\func_get_args());
+        return $this->lazyObjectReal->unwatch();
     }
 
     public function wait($numslaves, $timeout)
     {
-        return $this->lazyObjectReal->wait(...\func_get_args());
+        return $this->lazyObjectReal->wait($numslaves, $timeout);
     }
 
     public function watch($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->watch(...\func_get_args());
+        return $this->lazyObjectReal->watch($key, ...$other_keys);
     }
 
     public function xack($str_key, $str_group, $arr_ids)
     {
-        return $this->lazyObjectReal->xack(...\func_get_args());
+        return $this->lazyObjectReal->xack($str_key, $str_group, $arr_ids);
     }
 
     public function xadd($str_key, $str_id, $arr_fields, $i_maxlen = null, $boo_approximate = null)
     {
-        return $this->lazyObjectReal->xadd(...\func_get_args());
+        return $this->lazyObjectReal->xadd($str_key, $str_id, $arr_fields, $i_maxlen, $boo_approximate);
     }
 
     public function xclaim($str_key, $str_group, $str_consumer, $i_min_idle, $arr_ids, $arr_opts = null)
     {
-        return $this->lazyObjectReal->xclaim(...\func_get_args());
+        return $this->lazyObjectReal->xclaim($str_key, $str_group, $str_consumer, $i_min_idle, $arr_ids, $arr_opts);
     }
 
     public function xdel($str_key, $arr_ids)
     {
-        return $this->lazyObjectReal->xdel(...\func_get_args());
+        return $this->lazyObjectReal->xdel($str_key, $arr_ids);
     }
 
     public function xgroup($str_operation, $str_key = null, $str_arg1 = null, $str_arg2 = null, $str_arg3 = null)
     {
-        return $this->lazyObjectReal->xgroup(...\func_get_args());
+        return $this->lazyObjectReal->xgroup($str_operation, $str_key, $str_arg1, $str_arg2, $str_arg3);
     }
 
     public function xinfo($str_cmd, $str_key = null, $str_group = null)
     {
-        return $this->lazyObjectReal->xinfo(...\func_get_args());
+        return $this->lazyObjectReal->xinfo($str_cmd, $str_key, $str_group);
     }
 
     public function xlen($key)
     {
-        return $this->lazyObjectReal->xlen(...\func_get_args());
+        return $this->lazyObjectReal->xlen($key);
     }
 
     public function xpending($str_key, $str_group, $str_start = null, $str_end = null, $i_count = null, $str_consumer = null)
     {
-        return $this->lazyObjectReal->xpending(...\func_get_args());
+        return $this->lazyObjectReal->xpending($str_key, $str_group, $str_start, $str_end, $i_count, $str_consumer);
     }
 
     public function xrange($str_key, $str_start, $str_end, $i_count = null)
     {
-        return $this->lazyObjectReal->xrange(...\func_get_args());
+        return $this->lazyObjectReal->xrange($str_key, $str_start, $str_end, $i_count);
     }
 
     public function xread($arr_streams, $i_count = null, $i_block = null)
     {
-        return $this->lazyObjectReal->xread(...\func_get_args());
+        return $this->lazyObjectReal->xread($arr_streams, $i_count, $i_block);
     }
 
     public function xreadgroup($str_group, $str_consumer, $arr_streams, $i_count = null, $i_block = null)
     {
-        return $this->lazyObjectReal->xreadgroup(...\func_get_args());
+        return $this->lazyObjectReal->xreadgroup($str_group, $str_consumer, $arr_streams, $i_count, $i_block);
     }
 
     public function xrevrange($str_key, $str_start, $str_end, $i_count = null)
     {
-        return $this->lazyObjectReal->xrevrange(...\func_get_args());
+        return $this->lazyObjectReal->xrevrange($str_key, $str_start, $str_end, $i_count);
     }
 
     public function xtrim($str_key, $i_maxlen, $boo_approximate = null)
     {
-        return $this->lazyObjectReal->xtrim(...\func_get_args());
+        return $this->lazyObjectReal->xtrim($str_key, $i_maxlen, $boo_approximate);
     }
 
     public function zAdd($key, $score, $value, ...$extra_args)
     {
-        return $this->lazyObjectReal->zAdd(...\func_get_args());
+        return $this->lazyObjectReal->zAdd($key, $score, $value, ...$extra_args);
     }
 
     public function zCard($key)
     {
-        return $this->lazyObjectReal->zCard(...\func_get_args());
+        return $this->lazyObjectReal->zCard($key);
     }
 
     public function zCount($key, $min, $max)
     {
-        return $this->lazyObjectReal->zCount(...\func_get_args());
+        return $this->lazyObjectReal->zCount($key, $min, $max);
     }
 
     public function zIncrBy($key, $value, $member)
     {
-        return $this->lazyObjectReal->zIncrBy(...\func_get_args());
+        return $this->lazyObjectReal->zIncrBy($key, $value, $member);
     }
 
     public function zLexCount($key, $min, $max)
     {
-        return $this->lazyObjectReal->zLexCount(...\func_get_args());
+        return $this->lazyObjectReal->zLexCount($key, $min, $max);
     }
 
     public function zPopMax($key)
     {
-        return $this->lazyObjectReal->zPopMax(...\func_get_args());
+        return $this->lazyObjectReal->zPopMax($key);
     }
 
     public function zPopMin($key)
     {
-        return $this->lazyObjectReal->zPopMin(...\func_get_args());
+        return $this->lazyObjectReal->zPopMin($key);
     }
 
     public function zRange($key, $start, $end, $scores = null)
     {
-        return $this->lazyObjectReal->zRange(...\func_get_args());
+        return $this->lazyObjectReal->zRange($key, $start, $end, $scores);
     }
 
     public function zRangeByLex($key, $min, $max, $offset = null, $limit = null)
     {
-        return $this->lazyObjectReal->zRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRangeByLex($key, $min, $max, $offset, $limit);
     }
 
     public function zRangeByScore($key, $start, $end, $options = null)
     {
-        return $this->lazyObjectReal->zRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRangeByScore($key, $start, $end, $options);
     }
 
     public function zRank($key, $member)
     {
-        return $this->lazyObjectReal->zRank(...\func_get_args());
+        return $this->lazyObjectReal->zRank($key, $member);
     }
 
     public function zRem($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->zRem(...\func_get_args());
+        return $this->lazyObjectReal->zRem($key, $member, ...$other_members);
     }
 
     public function zRemRangeByLex($key, $min, $max)
     {
-        return $this->lazyObjectReal->zRemRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByLex($key, $min, $max);
     }
 
     public function zRemRangeByRank($key, $start, $end)
     {
-        return $this->lazyObjectReal->zRemRangeByRank(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByRank($key, $start, $end);
     }
 
     public function zRemRangeByScore($key, $min, $max)
     {
-        return $this->lazyObjectReal->zRemRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByScore($key, $min, $max);
     }
 
     public function zRevRange($key, $start, $end, $scores = null)
     {
-        return $this->lazyObjectReal->zRevRange(...\func_get_args());
+        return $this->lazyObjectReal->zRevRange($key, $start, $end, $scores);
     }
 
     public function zRevRangeByLex($key, $min, $max, $offset = null, $limit = null)
     {
-        return $this->lazyObjectReal->zRevRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRevRangeByLex($key, $min, $max, $offset, $limit);
     }
 
     public function zRevRangeByScore($key, $start, $end, $options = null)
     {
-        return $this->lazyObjectReal->zRevRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRevRangeByScore($key, $start, $end, $options);
     }
 
     public function zRevRank($key, $member)
     {
-        return $this->lazyObjectReal->zRevRank(...\func_get_args());
+        return $this->lazyObjectReal->zRevRank($key, $member);
     }
 
     public function zScore($key, $member)
     {
-        return $this->lazyObjectReal->zScore(...\func_get_args());
+        return $this->lazyObjectReal->zScore($key, $member);
     }
 
     public function zinterstore($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zinterstore(...\func_get_args());
+        return $this->lazyObjectReal->zinterstore($key, $keys, $weights, $aggregate);
     }
 
     public function zscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->zscan(...\func_get_args());
+        return $this->lazyObjectReal->zscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function zunionstore($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zunionstore(...\func_get_args());
+        return $this->lazyObjectReal->zunionstore($key, $keys, $weights, $aggregate);
     }
 
     public function delete($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->delete(...\func_get_args());
+        return $this->lazyObjectReal->delete($key, ...$other_keys);
     }
 
     public function evaluate($script, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->evaluate(...\func_get_args());
+        return $this->lazyObjectReal->evaluate($script, $args, $num_keys);
     }
 
     public function evaluateSha($script_sha, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->evaluateSha(...\func_get_args());
+        return $this->lazyObjectReal->evaluateSha($script_sha, $args, $num_keys);
     }
 
     public function getKeys($pattern)
     {
-        return $this->lazyObjectReal->getKeys(...\func_get_args());
+        return $this->lazyObjectReal->getKeys($pattern);
     }
 
     public function getMultiple($keys)
     {
-        return $this->lazyObjectReal->getMultiple(...\func_get_args());
+        return $this->lazyObjectReal->getMultiple($keys);
     }
 
     public function lGet($key, $index)
     {
-        return $this->lazyObjectReal->lGet(...\func_get_args());
+        return $this->lazyObjectReal->lGet($key, $index);
     }
 
     public function lGetRange($key, $start, $end)
     {
-        return $this->lazyObjectReal->lGetRange(...\func_get_args());
+        return $this->lazyObjectReal->lGetRange($key, $start, $end);
     }
 
     public function lRemove($key, $value, $count)
     {
-        return $this->lazyObjectReal->lRemove(...\func_get_args());
+        return $this->lazyObjectReal->lRemove($key, $value, $count);
     }
 
     public function lSize($key)
     {
-        return $this->lazyObjectReal->lSize(...\func_get_args());
+        return $this->lazyObjectReal->lSize($key);
     }
 
     public function listTrim($key, $start, $stop)
     {
-        return $this->lazyObjectReal->listTrim(...\func_get_args());
+        return $this->lazyObjectReal->listTrim($key, $start, $stop);
     }
 
     public function open($host, $port = null, $timeout = null, $retry_interval = null)
     {
-        return $this->lazyObjectReal->open(...\func_get_args());
+        return $this->lazyObjectReal->open($host, $port, $timeout, $retry_interval);
     }
 
     public function popen($host, $port = null, $timeout = null)
     {
-        return $this->lazyObjectReal->popen(...\func_get_args());
+        return $this->lazyObjectReal->popen($host, $port, $timeout);
     }
 
     public function renameKey($key, $newkey)
     {
-        return $this->lazyObjectReal->renameKey(...\func_get_args());
+        return $this->lazyObjectReal->renameKey($key, $newkey);
     }
 
     public function sContains($key, $value)
     {
-        return $this->lazyObjectReal->sContains(...\func_get_args());
+        return $this->lazyObjectReal->sContains($key, $value);
     }
 
     public function sGetMembers($key)
     {
-        return $this->lazyObjectReal->sGetMembers(...\func_get_args());
+        return $this->lazyObjectReal->sGetMembers($key);
     }
 
     public function sRemove($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->sRemove(...\func_get_args());
+        return $this->lazyObjectReal->sRemove($key, $member, ...$other_members);
     }
 
     public function sSize($key)
     {
-        return $this->lazyObjectReal->sSize(...\func_get_args());
+        return $this->lazyObjectReal->sSize($key);
     }
 
     public function sendEcho($msg)
     {
-        return $this->lazyObjectReal->sendEcho(...\func_get_args());
+        return $this->lazyObjectReal->sendEcho($msg);
     }
 
     public function setTimeout($key, $timeout)
     {
-        return $this->lazyObjectReal->setTimeout(...\func_get_args());
+        return $this->lazyObjectReal->setTimeout($key, $timeout);
     }
 
     public function substr($key, $start, $end)
     {
-        return $this->lazyObjectReal->substr(...\func_get_args());
+        return $this->lazyObjectReal->substr($key, $start, $end);
     }
 
     public function zDelete($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->zDelete(...\func_get_args());
+        return $this->lazyObjectReal->zDelete($key, $member, ...$other_members);
     }
 
     public function zDeleteRangeByRank($key, $min, $max)
     {
-        return $this->lazyObjectReal->zDeleteRangeByRank(...\func_get_args());
+        return $this->lazyObjectReal->zDeleteRangeByRank($key, $min, $max);
     }
 
     public function zDeleteRangeByScore($key, $min, $max)
     {
-        return $this->lazyObjectReal->zDeleteRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zDeleteRangeByScore($key, $min, $max);
     }
 
     public function zInter($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zInter(...\func_get_args());
+        return $this->lazyObjectReal->zInter($key, $keys, $weights, $aggregate);
     }
 
     public function zRemove($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->zRemove(...\func_get_args());
+        return $this->lazyObjectReal->zRemove($key, $member, ...$other_members);
     }
 
     public function zRemoveRangeByScore($key, $min, $max)
     {
-        return $this->lazyObjectReal->zRemoveRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRemoveRangeByScore($key, $min, $max);
     }
 
     public function zReverseRange($key, $start, $end, $scores = null)
     {
-        return $this->lazyObjectReal->zReverseRange(...\func_get_args());
+        return $this->lazyObjectReal->zReverseRange($key, $start, $end, $scores);
     }
 
     public function zSize($key)
     {
-        return $this->lazyObjectReal->zSize(...\func_get_args());
+        return $this->lazyObjectReal->zSize($key);
     }
 
     public function zUnion($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zUnion(...\func_get_args());
+        return $this->lazyObjectReal->zUnion($key, $keys, $weights, $aggregate);
     }
 }
diff --git a/src/Symfony/Component/Cache/Traits/Redis6Proxy.php b/src/Symfony/Component/Cache/Traits/Redis6Proxy.php
index 8d9ac740fd52c..321083ebf7cb4 100644
--- a/src/Symfony/Component/Cache/Traits/Redis6Proxy.php
+++ b/src/Symfony/Component/Cache/Traits/Redis6Proxy.php
@@ -36,1246 +36,1261 @@ class Redis6Proxy extends \Redis implements ResetInterface, LazyObjectInterface
 
     public function __construct($options = null)
     {
-        return $this->lazyObjectReal->__construct(...\func_get_args());
+        return $this->lazyObjectReal->__construct($options);
     }
 
     public function _compress($value): string
     {
-        return $this->lazyObjectReal->_compress(...\func_get_args());
+        return $this->lazyObjectReal->_compress($value);
     }
 
     public function _uncompress($value): string
     {
-        return $this->lazyObjectReal->_uncompress(...\func_get_args());
+        return $this->lazyObjectReal->_uncompress($value);
     }
 
     public function _prefix($key): string
     {
-        return $this->lazyObjectReal->_prefix(...\func_get_args());
+        return $this->lazyObjectReal->_prefix($key);
     }
 
     public function _serialize($value): string
     {
-        return $this->lazyObjectReal->_serialize(...\func_get_args());
+        return $this->lazyObjectReal->_serialize($value);
     }
 
     public function _unserialize($value): mixed
     {
-        return $this->lazyObjectReal->_unserialize(...\func_get_args());
+        return $this->lazyObjectReal->_unserialize($value);
     }
 
     public function _pack($value): string
     {
-        return $this->lazyObjectReal->_pack(...\func_get_args());
+        return $this->lazyObjectReal->_pack($value);
     }
 
     public function _unpack($value): mixed
     {
-        return $this->lazyObjectReal->_unpack(...\func_get_args());
+        return $this->lazyObjectReal->_unpack($value);
     }
 
     public function acl($subcmd, ...$args): mixed
     {
-        return $this->lazyObjectReal->acl(...\func_get_args());
+        return $this->lazyObjectReal->acl($subcmd, ...$args);
     }
 
     public function append($key, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->append(...\func_get_args());
+        return $this->lazyObjectReal->append($key, $value);
     }
 
     public function auth(#[\SensitiveParameter] $credentials): \Redis|bool
     {
-        return $this->lazyObjectReal->auth(...\func_get_args());
+        return $this->lazyObjectReal->auth($credentials);
     }
 
     public function bgSave(): \Redis|bool
     {
-        return $this->lazyObjectReal->bgSave(...\func_get_args());
+        return $this->lazyObjectReal->bgSave();
     }
 
     public function bgrewriteaof(): \Redis|bool
     {
-        return $this->lazyObjectReal->bgrewriteaof(...\func_get_args());
+        return $this->lazyObjectReal->bgrewriteaof();
     }
 
     public function bitcount($key, $start = 0, $end = -1, $bybit = false): \Redis|false|int
     {
-        return $this->lazyObjectReal->bitcount(...\func_get_args());
+        return $this->lazyObjectReal->bitcount($key, $start, $end, $bybit);
     }
 
     public function bitop($operation, $deskey, $srckey, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->bitop(...\func_get_args());
+        return $this->lazyObjectReal->bitop($operation, $deskey, $srckey, ...$other_keys);
     }
 
     public function bitpos($key, $bit, $start = 0, $end = -1, $bybit = false): \Redis|false|int
     {
-        return $this->lazyObjectReal->bitpos(...\func_get_args());
+        return $this->lazyObjectReal->bitpos($key, $bit, $start, $end, $bybit);
     }
 
     public function blPop($key_or_keys, $timeout_or_key, ...$extra_args): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->blPop(...\func_get_args());
+        return $this->lazyObjectReal->blPop($key_or_keys, $timeout_or_key, ...$extra_args);
     }
 
     public function brPop($key_or_keys, $timeout_or_key, ...$extra_args): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->brPop(...\func_get_args());
+        return $this->lazyObjectReal->brPop($key_or_keys, $timeout_or_key, ...$extra_args);
     }
 
     public function brpoplpush($src, $dst, $timeout): \Redis|false|string
     {
-        return $this->lazyObjectReal->brpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->brpoplpush($src, $dst, $timeout);
     }
 
     public function bzPopMax($key, $timeout_or_key, ...$extra_args): \Redis|array|false
     {
-        return $this->lazyObjectReal->bzPopMax(...\func_get_args());
+        return $this->lazyObjectReal->bzPopMax($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzPopMin($key, $timeout_or_key, ...$extra_args): \Redis|array|false
     {
-        return $this->lazyObjectReal->bzPopMin(...\func_get_args());
+        return $this->lazyObjectReal->bzPopMin($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzmpop($timeout, $keys, $from, $count = 1): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->bzmpop(...\func_get_args());
+        return $this->lazyObjectReal->bzmpop($timeout, $keys, $from, $count);
     }
 
     public function zmpop($keys, $from, $count = 1): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->zmpop(...\func_get_args());
+        return $this->lazyObjectReal->zmpop($keys, $from, $count);
     }
 
     public function blmpop($timeout, $keys, $from, $count = 1): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->blmpop(...\func_get_args());
+        return $this->lazyObjectReal->blmpop($timeout, $keys, $from, $count);
     }
 
     public function lmpop($keys, $from, $count = 1): \Redis|array|false|null
     {
-        return $this->lazyObjectReal->lmpop(...\func_get_args());
+        return $this->lazyObjectReal->lmpop($keys, $from, $count);
     }
 
     public function clearLastError(): bool
     {
-        return $this->lazyObjectReal->clearLastError(...\func_get_args());
+        return $this->lazyObjectReal->clearLastError();
     }
 
     public function client($opt, ...$args): mixed
     {
-        return $this->lazyObjectReal->client(...\func_get_args());
+        return $this->lazyObjectReal->client($opt, ...$args);
     }
 
     public function close(): bool
     {
-        return $this->lazyObjectReal->close(...\func_get_args());
+        return $this->lazyObjectReal->close();
     }
 
     public function command($opt = null, ...$args): mixed
     {
-        return $this->lazyObjectReal->command(...\func_get_args());
+        return $this->lazyObjectReal->command($opt, ...$args);
     }
 
     public function config($operation, $key_or_settings = null, $value = null): mixed
     {
-        return $this->lazyObjectReal->config(...\func_get_args());
+        return $this->lazyObjectReal->config($operation, $key_or_settings, $value);
     }
 
     public function connect($host, $port = 6379, $timeout = 0.0, $persistent_id = null, $retry_interval = 0, $read_timeout = 0.0, $context = null): bool
     {
-        return $this->lazyObjectReal->connect(...\func_get_args());
+        return $this->lazyObjectReal->connect($host, $port, $timeout, $persistent_id, $retry_interval, $read_timeout, $context);
     }
 
     public function copy($src, $dst, $options = null): \Redis|bool
     {
-        return $this->lazyObjectReal->copy(...\func_get_args());
+        return $this->lazyObjectReal->copy($src, $dst, $options);
     }
 
     public function dbSize(): \Redis|false|int
     {
-        return $this->lazyObjectReal->dbSize(...\func_get_args());
+        return $this->lazyObjectReal->dbSize();
     }
 
     public function debug($key): \Redis|string
     {
-        return $this->lazyObjectReal->debug(...\func_get_args());
+        return $this->lazyObjectReal->debug($key);
     }
 
     public function decr($key, $by = 1): \Redis|false|int
     {
-        return $this->lazyObjectReal->decr(...\func_get_args());
+        return $this->lazyObjectReal->decr($key, $by);
     }
 
     public function decrBy($key, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->decrBy(...\func_get_args());
+        return $this->lazyObjectReal->decrBy($key, $value);
     }
 
     public function del($key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->del(...\func_get_args());
+        return $this->lazyObjectReal->del($key, ...$other_keys);
     }
 
     public function delete($key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->delete(...\func_get_args());
+        return $this->lazyObjectReal->delete($key, ...$other_keys);
     }
 
     public function discard(): \Redis|bool
     {
-        return $this->lazyObjectReal->discard(...\func_get_args());
+        return $this->lazyObjectReal->discard();
     }
 
     public function dump($key): \Redis|string
     {
-        return $this->lazyObjectReal->dump(...\func_get_args());
+        return $this->lazyObjectReal->dump($key);
     }
 
     public function echo($str): \Redis|false|string
     {
-        return $this->lazyObjectReal->echo(...\func_get_args());
+        return $this->lazyObjectReal->echo($str);
     }
 
     public function eval($script, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->eval(...\func_get_args());
+        return $this->lazyObjectReal->eval($script, $args, $num_keys);
     }
 
     public function eval_ro($script_sha, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->eval_ro(...\func_get_args());
+        return $this->lazyObjectReal->eval_ro($script_sha, $args, $num_keys);
     }
 
     public function evalsha($sha1, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->evalsha(...\func_get_args());
+        return $this->lazyObjectReal->evalsha($sha1, $args, $num_keys);
     }
 
     public function evalsha_ro($sha1, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->evalsha_ro(...\func_get_args());
+        return $this->lazyObjectReal->evalsha_ro($sha1, $args, $num_keys);
     }
 
     public function exec(): \Redis|array|false
     {
-        return $this->lazyObjectReal->exec(...\func_get_args());
+        return $this->lazyObjectReal->exec();
     }
 
     public function exists($key, ...$other_keys): \Redis|bool|int
     {
-        return $this->lazyObjectReal->exists(...\func_get_args());
+        return $this->lazyObjectReal->exists($key, ...$other_keys);
     }
 
     public function expire($key, $timeout, $mode = null): \Redis|bool
     {
-        return $this->lazyObjectReal->expire(...\func_get_args());
+        return $this->lazyObjectReal->expire($key, $timeout, $mode);
     }
 
     public function expireAt($key, $timestamp, $mode = null): \Redis|bool
     {
-        return $this->lazyObjectReal->expireAt(...\func_get_args());
+        return $this->lazyObjectReal->expireAt($key, $timestamp, $mode);
     }
 
     public function failover($to = null, $abort = false, $timeout = 0): \Redis|bool
     {
-        return $this->lazyObjectReal->failover(...\func_get_args());
+        return $this->lazyObjectReal->failover($to, $abort, $timeout);
     }
 
     public function expiretime($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->expiretime(...\func_get_args());
+        return $this->lazyObjectReal->expiretime($key);
     }
 
     public function pexpiretime($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->pexpiretime(...\func_get_args());
+        return $this->lazyObjectReal->pexpiretime($key);
+    }
+
+    public function fcall($fn, $keys = [], $args = []): mixed
+    {
+        return $this->lazyObjectReal->fcall($fn, $keys, $args);
+    }
+
+    public function fcall_ro($fn, $keys = [], $args = []): mixed
+    {
+        return $this->lazyObjectReal->fcall_ro($fn, $keys, $args);
     }
 
     public function flushAll($sync = null): \Redis|bool
     {
-        return $this->lazyObjectReal->flushAll(...\func_get_args());
+        return $this->lazyObjectReal->flushAll($sync);
     }
 
     public function flushDB($sync = null): \Redis|bool
     {
-        return $this->lazyObjectReal->flushDB(...\func_get_args());
+        return $this->lazyObjectReal->flushDB($sync);
+    }
+
+    public function function($operation, ...$args): \Redis|array|bool|string
+    {
+        return $this->lazyObjectReal->function($operation, ...$args);
     }
 
     public function geoadd($key, $lng, $lat, $member, ...$other_triples_and_options): \Redis|false|int
     {
-        return $this->lazyObjectReal->geoadd(...\func_get_args());
+        return $this->lazyObjectReal->geoadd($key, $lng, $lat, $member, ...$other_triples_and_options);
     }
 
     public function geodist($key, $src, $dst, $unit = null): \Redis|false|float
     {
-        return $this->lazyObjectReal->geodist(...\func_get_args());
+        return $this->lazyObjectReal->geodist($key, $src, $dst, $unit);
     }
 
     public function geohash($key, $member, ...$other_members): \Redis|array|false
     {
-        return $this->lazyObjectReal->geohash(...\func_get_args());
+        return $this->lazyObjectReal->geohash($key, $member, ...$other_members);
     }
 
     public function geopos($key, $member, ...$other_members): \Redis|array|false
     {
-        return $this->lazyObjectReal->geopos(...\func_get_args());
+        return $this->lazyObjectReal->geopos($key, $member, ...$other_members);
     }
 
     public function georadius($key, $lng, $lat, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadius(...\func_get_args());
+        return $this->lazyObjectReal->georadius($key, $lng, $lat, $radius, $unit, $options);
     }
 
     public function georadius_ro($key, $lng, $lat, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadius_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadius_ro($key, $lng, $lat, $radius, $unit, $options);
     }
 
     public function georadiusbymember($key, $member, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadiusbymember(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember($key, $member, $radius, $unit, $options);
     }
 
     public function georadiusbymember_ro($key, $member, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadiusbymember_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember_ro($key, $member, $radius, $unit, $options);
     }
 
     public function geosearch($key, $position, $shape, $unit, $options = []): array
     {
-        return $this->lazyObjectReal->geosearch(...\func_get_args());
+        return $this->lazyObjectReal->geosearch($key, $position, $shape, $unit, $options);
     }
 
     public function geosearchstore($dst, $src, $position, $shape, $unit, $options = []): \Redis|array|false|int
     {
-        return $this->lazyObjectReal->geosearchstore(...\func_get_args());
+        return $this->lazyObjectReal->geosearchstore($dst, $src, $position, $shape, $unit, $options);
     }
 
     public function get($key): mixed
     {
-        return $this->lazyObjectReal->get(...\func_get_args());
+        return $this->lazyObjectReal->get($key);
     }
 
     public function getAuth(): mixed
     {
-        return $this->lazyObjectReal->getAuth(...\func_get_args());
+        return $this->lazyObjectReal->getAuth();
     }
 
     public function getBit($key, $idx): \Redis|false|int
     {
-        return $this->lazyObjectReal->getBit(...\func_get_args());
+        return $this->lazyObjectReal->getBit($key, $idx);
     }
 
     public function getEx($key, $options = []): \Redis|bool|string
     {
-        return $this->lazyObjectReal->getEx(...\func_get_args());
+        return $this->lazyObjectReal->getEx($key, $options);
     }
 
     public function getDBNum(): int
     {
-        return $this->lazyObjectReal->getDBNum(...\func_get_args());
+        return $this->lazyObjectReal->getDBNum();
     }
 
     public function getDel($key): \Redis|bool|string
     {
-        return $this->lazyObjectReal->getDel(...\func_get_args());
+        return $this->lazyObjectReal->getDel($key);
     }
 
     public function getHost(): string
     {
-        return $this->lazyObjectReal->getHost(...\func_get_args());
+        return $this->lazyObjectReal->getHost();
     }
 
     public function getLastError(): ?string
     {
-        return $this->lazyObjectReal->getLastError(...\func_get_args());
+        return $this->lazyObjectReal->getLastError();
     }
 
     public function getMode(): int
     {
-        return $this->lazyObjectReal->getMode(...\func_get_args());
+        return $this->lazyObjectReal->getMode();
     }
 
     public function getOption($option): mixed
     {
-        return $this->lazyObjectReal->getOption(...\func_get_args());
+        return $this->lazyObjectReal->getOption($option);
     }
 
     public function getPersistentID(): ?string
     {
-        return $this->lazyObjectReal->getPersistentID(...\func_get_args());
+        return $this->lazyObjectReal->getPersistentID();
     }
 
     public function getPort(): int
     {
-        return $this->lazyObjectReal->getPort(...\func_get_args());
+        return $this->lazyObjectReal->getPort();
     }
 
     public function getRange($key, $start, $end): \Redis|false|string
     {
-        return $this->lazyObjectReal->getRange(...\func_get_args());
+        return $this->lazyObjectReal->getRange($key, $start, $end);
     }
 
     public function lcs($key1, $key2, $options = null): \Redis|array|false|int|string
     {
-        return $this->lazyObjectReal->lcs(...\func_get_args());
+        return $this->lazyObjectReal->lcs($key1, $key2, $options);
     }
 
     public function getReadTimeout(): float
     {
-        return $this->lazyObjectReal->getReadTimeout(...\func_get_args());
+        return $this->lazyObjectReal->getReadTimeout();
     }
 
     public function getset($key, $value): \Redis|false|string
     {
-        return $this->lazyObjectReal->getset(...\func_get_args());
+        return $this->lazyObjectReal->getset($key, $value);
     }
 
     public function getTimeout(): false|float
     {
-        return $this->lazyObjectReal->getTimeout(...\func_get_args());
+        return $this->lazyObjectReal->getTimeout();
     }
 
     public function getTransferredBytes(): array
     {
-        return $this->lazyObjectReal->getTransferredBytes(...\func_get_args());
+        return $this->lazyObjectReal->getTransferredBytes();
     }
 
     public function clearTransferredBytes(): void
     {
-        $this->lazyObjectReal->clearTransferredBytes(...\func_get_args());
+        $this->lazyObjectReal->clearTransferredBytes();
     }
 
     public function hDel($key, $field, ...$other_fields): \Redis|false|int
     {
-        return $this->lazyObjectReal->hDel(...\func_get_args());
+        return $this->lazyObjectReal->hDel($key, $field, ...$other_fields);
     }
 
     public function hExists($key, $field): \Redis|bool
     {
-        return $this->lazyObjectReal->hExists(...\func_get_args());
+        return $this->lazyObjectReal->hExists($key, $field);
     }
 
     public function hGet($key, $member): mixed
     {
-        return $this->lazyObjectReal->hGet(...\func_get_args());
+        return $this->lazyObjectReal->hGet($key, $member);
     }
 
     public function hGetAll($key): \Redis|array|false
     {
-        return $this->lazyObjectReal->hGetAll(...\func_get_args());
+        return $this->lazyObjectReal->hGetAll($key);
     }
 
     public function hIncrBy($key, $field, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->hIncrBy(...\func_get_args());
+        return $this->lazyObjectReal->hIncrBy($key, $field, $value);
     }
 
     public function hIncrByFloat($key, $field, $value): \Redis|false|float
     {
-        return $this->lazyObjectReal->hIncrByFloat(...\func_get_args());
+        return $this->lazyObjectReal->hIncrByFloat($key, $field, $value);
     }
 
     public function hKeys($key): \Redis|array|false
     {
-        return $this->lazyObjectReal->hKeys(...\func_get_args());
+        return $this->lazyObjectReal->hKeys($key);
     }
 
     public function hLen($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->hLen(...\func_get_args());
+        return $this->lazyObjectReal->hLen($key);
     }
 
     public function hMget($key, $fields): \Redis|array|false
     {
-        return $this->lazyObjectReal->hMget(...\func_get_args());
+        return $this->lazyObjectReal->hMget($key, $fields);
     }
 
     public function hMset($key, $fieldvals): \Redis|bool
     {
-        return $this->lazyObjectReal->hMset(...\func_get_args());
+        return $this->lazyObjectReal->hMset($key, $fieldvals);
     }
 
     public function hRandField($key, $options = null): \Redis|array|string
     {
-        return $this->lazyObjectReal->hRandField(...\func_get_args());
+        return $this->lazyObjectReal->hRandField($key, $options);
     }
 
     public function hSet($key, $member, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->hSet(...\func_get_args());
+        return $this->lazyObjectReal->hSet($key, $member, $value);
     }
 
     public function hSetNx($key, $field, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->hSetNx(...\func_get_args());
+        return $this->lazyObjectReal->hSetNx($key, $field, $value);
     }
 
     public function hStrLen($key, $field): \Redis|false|int
     {
-        return $this->lazyObjectReal->hStrLen(...\func_get_args());
+        return $this->lazyObjectReal->hStrLen($key, $field);
     }
 
     public function hVals($key): \Redis|array|false
     {
-        return $this->lazyObjectReal->hVals(...\func_get_args());
+        return $this->lazyObjectReal->hVals($key);
     }
 
     public function hscan($key, &$iterator, $pattern = null, $count = 0): \Redis|array|bool
     {
-        return $this->lazyObjectReal->hscan(...\func_get_args());
+        return $this->lazyObjectReal->hscan($key, $iterator, $pattern, $count);
     }
 
     public function incr($key, $by = 1): \Redis|false|int
     {
-        return $this->lazyObjectReal->incr(...\func_get_args());
+        return $this->lazyObjectReal->incr($key, $by);
     }
 
     public function incrBy($key, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->incrBy(...\func_get_args());
+        return $this->lazyObjectReal->incrBy($key, $value);
     }
 
     public function incrByFloat($key, $value): \Redis|false|float
     {
-        return $this->lazyObjectReal->incrByFloat(...\func_get_args());
+        return $this->lazyObjectReal->incrByFloat($key, $value);
     }
 
     public function info(...$sections): \Redis|array|false
     {
-        return $this->lazyObjectReal->info(...\func_get_args());
+        return $this->lazyObjectReal->info(...$sections);
     }
 
     public function isConnected(): bool
     {
-        return $this->lazyObjectReal->isConnected(...\func_get_args());
+        return $this->lazyObjectReal->isConnected();
     }
 
     public function keys($pattern)
     {
-        return $this->lazyObjectReal->keys(...\func_get_args());
+        return $this->lazyObjectReal->keys($pattern);
     }
 
     public function lInsert($key, $pos, $pivot, $value)
     {
-        return $this->lazyObjectReal->lInsert(...\func_get_args());
+        return $this->lazyObjectReal->lInsert($key, $pos, $pivot, $value);
     }
 
     public function lLen($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->lLen(...\func_get_args());
+        return $this->lazyObjectReal->lLen($key);
     }
 
     public function lMove($src, $dst, $wherefrom, $whereto): \Redis|false|string
     {
-        return $this->lazyObjectReal->lMove(...\func_get_args());
+        return $this->lazyObjectReal->lMove($src, $dst, $wherefrom, $whereto);
     }
 
     public function blmove($src, $dst, $wherefrom, $whereto, $timeout): \Redis|false|string
     {
-        return $this->lazyObjectReal->blmove(...\func_get_args());
+        return $this->lazyObjectReal->blmove($src, $dst, $wherefrom, $whereto, $timeout);
     }
 
     public function lPop($key, $count = 0): \Redis|array|bool|string
     {
-        return $this->lazyObjectReal->lPop(...\func_get_args());
+        return $this->lazyObjectReal->lPop($key, $count);
     }
 
     public function lPos($key, $value, $options = null): \Redis|array|bool|int|null
     {
-        return $this->lazyObjectReal->lPos(...\func_get_args());
+        return $this->lazyObjectReal->lPos($key, $value, $options);
     }
 
     public function lPush($key, ...$elements): \Redis|false|int
     {
-        return $this->lazyObjectReal->lPush(...\func_get_args());
+        return $this->lazyObjectReal->lPush($key, ...$elements);
     }
 
     public function rPush($key, ...$elements): \Redis|false|int
     {
-        return $this->lazyObjectReal->rPush(...\func_get_args());
+        return $this->lazyObjectReal->rPush($key, ...$elements);
     }
 
     public function lPushx($key, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->lPushx(...\func_get_args());
+        return $this->lazyObjectReal->lPushx($key, $value);
     }
 
     public function rPushx($key, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->rPushx(...\func_get_args());
+        return $this->lazyObjectReal->rPushx($key, $value);
     }
 
     public function lSet($key, $index, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->lSet(...\func_get_args());
+        return $this->lazyObjectReal->lSet($key, $index, $value);
     }
 
     public function lastSave(): int
     {
-        return $this->lazyObjectReal->lastSave(...\func_get_args());
+        return $this->lazyObjectReal->lastSave();
     }
 
     public function lindex($key, $index): mixed
     {
-        return $this->lazyObjectReal->lindex(...\func_get_args());
+        return $this->lazyObjectReal->lindex($key, $index);
     }
 
     public function lrange($key, $start, $end): \Redis|array|false
     {
-        return $this->lazyObjectReal->lrange(...\func_get_args());
+        return $this->lazyObjectReal->lrange($key, $start, $end);
     }
 
     public function lrem($key, $value, $count = 0): \Redis|false|int
     {
-        return $this->lazyObjectReal->lrem(...\func_get_args());
+        return $this->lazyObjectReal->lrem($key, $value, $count);
     }
 
     public function ltrim($key, $start, $end): \Redis|bool
     {
-        return $this->lazyObjectReal->ltrim(...\func_get_args());
+        return $this->lazyObjectReal->ltrim($key, $start, $end);
     }
 
     public function mget($keys): \Redis|array
     {
-        return $this->lazyObjectReal->mget(...\func_get_args());
+        return $this->lazyObjectReal->mget($keys);
     }
 
     public function migrate($host, $port, $key, $dstdb, $timeout, $copy = false, $replace = false, #[\SensitiveParameter] $credentials = null): \Redis|bool
     {
-        return $this->lazyObjectReal->migrate(...\func_get_args());
+        return $this->lazyObjectReal->migrate($host, $port, $key, $dstdb, $timeout, $copy, $replace, $credentials);
     }
 
     public function move($key, $index): \Redis|bool
     {
-        return $this->lazyObjectReal->move(...\func_get_args());
+        return $this->lazyObjectReal->move($key, $index);
     }
 
     public function mset($key_values): \Redis|bool
     {
-        return $this->lazyObjectReal->mset(...\func_get_args());
+        return $this->lazyObjectReal->mset($key_values);
     }
 
     public function msetnx($key_values): \Redis|bool
     {
-        return $this->lazyObjectReal->msetnx(...\func_get_args());
+        return $this->lazyObjectReal->msetnx($key_values);
     }
 
     public function multi($value = \Redis::MULTI): \Redis|bool
     {
-        return $this->lazyObjectReal->multi(...\func_get_args());
+        return $this->lazyObjectReal->multi($value);
     }
 
     public function object($subcommand, $key): \Redis|false|int|string
     {
-        return $this->lazyObjectReal->object(...\func_get_args());
+        return $this->lazyObjectReal->object($subcommand, $key);
     }
 
     public function open($host, $port = 6379, $timeout = 0.0, $persistent_id = null, $retry_interval = 0, $read_timeout = 0.0, $context = null): bool
     {
-        return $this->lazyObjectReal->open(...\func_get_args());
+        return $this->lazyObjectReal->open($host, $port, $timeout, $persistent_id, $retry_interval, $read_timeout, $context);
     }
 
     public function pconnect($host, $port = 6379, $timeout = 0.0, $persistent_id = null, $retry_interval = 0, $read_timeout = 0.0, $context = null): bool
     {
-        return $this->lazyObjectReal->pconnect(...\func_get_args());
+        return $this->lazyObjectReal->pconnect($host, $port, $timeout, $persistent_id, $retry_interval, $read_timeout, $context);
     }
 
     public function persist($key): \Redis|bool
     {
-        return $this->lazyObjectReal->persist(...\func_get_args());
+        return $this->lazyObjectReal->persist($key);
     }
 
     public function pexpire($key, $timeout, $mode = null): bool
     {
-        return $this->lazyObjectReal->pexpire(...\func_get_args());
+        return $this->lazyObjectReal->pexpire($key, $timeout, $mode);
     }
 
     public function pexpireAt($key, $timestamp, $mode = null): \Redis|bool
     {
-        return $this->lazyObjectReal->pexpireAt(...\func_get_args());
+        return $this->lazyObjectReal->pexpireAt($key, $timestamp, $mode);
     }
 
     public function pfadd($key, $elements): \Redis|int
     {
-        return $this->lazyObjectReal->pfadd(...\func_get_args());
+        return $this->lazyObjectReal->pfadd($key, $elements);
     }
 
-    public function pfcount($key): \Redis|int
+    public function pfcount($key_or_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->pfcount(...\func_get_args());
+        return $this->lazyObjectReal->pfcount($key_or_keys);
     }
 
     public function pfmerge($dst, $srckeys): \Redis|bool
     {
-        return $this->lazyObjectReal->pfmerge(...\func_get_args());
+        return $this->lazyObjectReal->pfmerge($dst, $srckeys);
     }
 
     public function ping($message = null): \Redis|bool|string
     {
-        return $this->lazyObjectReal->ping(...\func_get_args());
+        return $this->lazyObjectReal->ping($message);
     }
 
     public function pipeline(): \Redis|bool
     {
-        return $this->lazyObjectReal->pipeline(...\func_get_args());
+        return $this->lazyObjectReal->pipeline();
     }
 
     public function popen($host, $port = 6379, $timeout = 0.0, $persistent_id = null, $retry_interval = 0, $read_timeout = 0.0, $context = null): bool
     {
-        return $this->lazyObjectReal->popen(...\func_get_args());
+        return $this->lazyObjectReal->popen($host, $port, $timeout, $persistent_id, $retry_interval, $read_timeout, $context);
     }
 
     public function psetex($key, $expire, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->psetex(...\func_get_args());
+        return $this->lazyObjectReal->psetex($key, $expire, $value);
     }
 
     public function psubscribe($patterns, $cb): bool
     {
-        return $this->lazyObjectReal->psubscribe(...\func_get_args());
+        return $this->lazyObjectReal->psubscribe($patterns, $cb);
     }
 
     public function pttl($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->pttl(...\func_get_args());
+        return $this->lazyObjectReal->pttl($key);
     }
 
     public function publish($channel, $message): \Redis|false|int
     {
-        return $this->lazyObjectReal->publish(...\func_get_args());
+        return $this->lazyObjectReal->publish($channel, $message);
     }
 
     public function pubsub($command, $arg = null): mixed
     {
-        return $this->lazyObjectReal->pubsub(...\func_get_args());
+        return $this->lazyObjectReal->pubsub($command, $arg);
     }
 
     public function punsubscribe($patterns): \Redis|array|bool
     {
-        return $this->lazyObjectReal->punsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->punsubscribe($patterns);
     }
 
     public function rPop($key, $count = 0): \Redis|array|bool|string
     {
-        return $this->lazyObjectReal->rPop(...\func_get_args());
+        return $this->lazyObjectReal->rPop($key, $count);
     }
 
     public function randomKey(): \Redis|false|string
     {
-        return $this->lazyObjectReal->randomKey(...\func_get_args());
+        return $this->lazyObjectReal->randomKey();
     }
 
     public function rawcommand($command, ...$args): mixed
     {
-        return $this->lazyObjectReal->rawcommand(...\func_get_args());
+        return $this->lazyObjectReal->rawcommand($command, ...$args);
     }
 
     public function rename($old_name, $new_name): \Redis|bool
     {
-        return $this->lazyObjectReal->rename(...\func_get_args());
+        return $this->lazyObjectReal->rename($old_name, $new_name);
     }
 
     public function renameNx($key_src, $key_dst): \Redis|bool
     {
-        return $this->lazyObjectReal->renameNx(...\func_get_args());
+        return $this->lazyObjectReal->renameNx($key_src, $key_dst);
     }
 
     public function restore($key, $ttl, $value, $options = null): \Redis|bool
     {
-        return $this->lazyObjectReal->restore(...\func_get_args());
+        return $this->lazyObjectReal->restore($key, $ttl, $value, $options);
     }
 
     public function role(): mixed
     {
-        return $this->lazyObjectReal->role(...\func_get_args());
+        return $this->lazyObjectReal->role();
     }
 
     public function rpoplpush($srckey, $dstkey): \Redis|false|string
     {
-        return $this->lazyObjectReal->rpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->rpoplpush($srckey, $dstkey);
     }
 
     public function sAdd($key, $value, ...$other_values): \Redis|false|int
     {
-        return $this->lazyObjectReal->sAdd(...\func_get_args());
+        return $this->lazyObjectReal->sAdd($key, $value, ...$other_values);
     }
 
     public function sAddArray($key, $values): int
     {
-        return $this->lazyObjectReal->sAddArray(...\func_get_args());
+        return $this->lazyObjectReal->sAddArray($key, $values);
     }
 
     public function sDiff($key, ...$other_keys): \Redis|array|false
     {
-        return $this->lazyObjectReal->sDiff(...\func_get_args());
+        return $this->lazyObjectReal->sDiff($key, ...$other_keys);
     }
 
     public function sDiffStore($dst, $key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->sDiffStore(...\func_get_args());
+        return $this->lazyObjectReal->sDiffStore($dst, $key, ...$other_keys);
     }
 
     public function sInter($key, ...$other_keys): \Redis|array|false
     {
-        return $this->lazyObjectReal->sInter(...\func_get_args());
+        return $this->lazyObjectReal->sInter($key, ...$other_keys);
     }
 
     public function sintercard($keys, $limit = -1): \Redis|false|int
     {
-        return $this->lazyObjectReal->sintercard(...\func_get_args());
+        return $this->lazyObjectReal->sintercard($keys, $limit);
     }
 
     public function sInterStore($key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->sInterStore(...\func_get_args());
+        return $this->lazyObjectReal->sInterStore($key, ...$other_keys);
     }
 
     public function sMembers($key): \Redis|array|false
     {
-        return $this->lazyObjectReal->sMembers(...\func_get_args());
+        return $this->lazyObjectReal->sMembers($key);
     }
 
     public function sMisMember($key, $member, ...$other_members): \Redis|array|false
     {
-        return $this->lazyObjectReal->sMisMember(...\func_get_args());
+        return $this->lazyObjectReal->sMisMember($key, $member, ...$other_members);
     }
 
     public function sMove($src, $dst, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->sMove(...\func_get_args());
+        return $this->lazyObjectReal->sMove($src, $dst, $value);
     }
 
     public function sPop($key, $count = 0): \Redis|array|false|string
     {
-        return $this->lazyObjectReal->sPop(...\func_get_args());
+        return $this->lazyObjectReal->sPop($key, $count);
     }
 
     public function sRandMember($key, $count = 0): \Redis|array|false|string
     {
-        return $this->lazyObjectReal->sRandMember(...\func_get_args());
+        return $this->lazyObjectReal->sRandMember($key, $count);
     }
 
     public function sUnion($key, ...$other_keys): \Redis|array|false
     {
-        return $this->lazyObjectReal->sUnion(...\func_get_args());
+        return $this->lazyObjectReal->sUnion($key, ...$other_keys);
     }
 
     public function sUnionStore($dst, $key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->sUnionStore(...\func_get_args());
+        return $this->lazyObjectReal->sUnionStore($dst, $key, ...$other_keys);
     }
 
     public function save(): \Redis|bool
     {
-        return $this->lazyObjectReal->save(...\func_get_args());
+        return $this->lazyObjectReal->save();
     }
 
     public function scan(&$iterator, $pattern = null, $count = 0, $type = null): array|false
     {
-        return $this->lazyObjectReal->scan(...\func_get_args());
+        return $this->lazyObjectReal->scan($iterator, $pattern, $count, $type);
     }
 
     public function scard($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->scard(...\func_get_args());
+        return $this->lazyObjectReal->scard($key);
     }
 
     public function script($command, ...$args): mixed
     {
-        return $this->lazyObjectReal->script(...\func_get_args());
+        return $this->lazyObjectReal->script($command, ...$args);
     }
 
     public function select($db): \Redis|bool
     {
-        return $this->lazyObjectReal->select(...\func_get_args());
+        return $this->lazyObjectReal->select($db);
     }
 
     public function set($key, $value, $options = null): \Redis|bool|string
     {
-        return $this->lazyObjectReal->set(...\func_get_args());
+        return $this->lazyObjectReal->set($key, $value, $options);
     }
 
     public function setBit($key, $idx, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->setBit(...\func_get_args());
+        return $this->lazyObjectReal->setBit($key, $idx, $value);
     }
 
     public function setRange($key, $index, $value): \Redis|false|int
     {
-        return $this->lazyObjectReal->setRange(...\func_get_args());
+        return $this->lazyObjectReal->setRange($key, $index, $value);
     }
 
     public function setOption($option, $value): bool
     {
-        return $this->lazyObjectReal->setOption(...\func_get_args());
+        return $this->lazyObjectReal->setOption($option, $value);
     }
 
     public function setex($key, $expire, $value)
     {
-        return $this->lazyObjectReal->setex(...\func_get_args());
+        return $this->lazyObjectReal->setex($key, $expire, $value);
     }
 
     public function setnx($key, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->setnx(...\func_get_args());
+        return $this->lazyObjectReal->setnx($key, $value);
     }
 
     public function sismember($key, $value): \Redis|bool
     {
-        return $this->lazyObjectReal->sismember(...\func_get_args());
+        return $this->lazyObjectReal->sismember($key, $value);
     }
 
     public function slaveof($host = null, $port = 6379): \Redis|bool
     {
-        return $this->lazyObjectReal->slaveof(...\func_get_args());
+        return $this->lazyObjectReal->slaveof($host, $port);
     }
 
     public function replicaof($host = null, $port = 6379): \Redis|bool
     {
-        return $this->lazyObjectReal->replicaof(...\func_get_args());
+        return $this->lazyObjectReal->replicaof($host, $port);
     }
 
     public function touch($key_or_array, ...$more_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->touch(...\func_get_args());
+        return $this->lazyObjectReal->touch($key_or_array, ...$more_keys);
     }
 
     public function slowlog($operation, $length = 0): mixed
     {
-        return $this->lazyObjectReal->slowlog(...\func_get_args());
+        return $this->lazyObjectReal->slowlog($operation, $length);
     }
 
     public function sort($key, $options = null): mixed
     {
-        return $this->lazyObjectReal->sort(...\func_get_args());
+        return $this->lazyObjectReal->sort($key, $options);
     }
 
     public function sort_ro($key, $options = null): mixed
     {
-        return $this->lazyObjectReal->sort_ro(...\func_get_args());
+        return $this->lazyObjectReal->sort_ro($key, $options);
     }
 
     public function sortAsc($key, $pattern = null, $get = null, $offset = -1, $count = -1, $store = null): array
     {
-        return $this->lazyObjectReal->sortAsc(...\func_get_args());
+        return $this->lazyObjectReal->sortAsc($key, $pattern, $get, $offset, $count, $store);
     }
 
     public function sortAscAlpha($key, $pattern = null, $get = null, $offset = -1, $count = -1, $store = null): array
     {
-        return $this->lazyObjectReal->sortAscAlpha(...\func_get_args());
+        return $this->lazyObjectReal->sortAscAlpha($key, $pattern, $get, $offset, $count, $store);
     }
 
     public function sortDesc($key, $pattern = null, $get = null, $offset = -1, $count = -1, $store = null): array
     {
-        return $this->lazyObjectReal->sortDesc(...\func_get_args());
+        return $this->lazyObjectReal->sortDesc($key, $pattern, $get, $offset, $count, $store);
     }
 
     public function sortDescAlpha($key, $pattern = null, $get = null, $offset = -1, $count = -1, $store = null): array
     {
-        return $this->lazyObjectReal->sortDescAlpha(...\func_get_args());
+        return $this->lazyObjectReal->sortDescAlpha($key, $pattern, $get, $offset, $count, $store);
     }
 
     public function srem($key, $value, ...$other_values): \Redis|false|int
     {
-        return $this->lazyObjectReal->srem(...\func_get_args());
+        return $this->lazyObjectReal->srem($key, $value, ...$other_values);
     }
 
     public function sscan($key, &$iterator, $pattern = null, $count = 0): array|false
     {
-        return $this->lazyObjectReal->sscan(...\func_get_args());
+        return $this->lazyObjectReal->sscan($key, $iterator, $pattern, $count);
     }
 
     public function ssubscribe($channels, $cb): bool
     {
-        return $this->lazyObjectReal->ssubscribe(...\func_get_args());
+        return $this->lazyObjectReal->ssubscribe($channels, $cb);
     }
 
     public function strlen($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->strlen(...\func_get_args());
+        return $this->lazyObjectReal->strlen($key);
     }
 
     public function subscribe($channels, $cb): bool
     {
-        return $this->lazyObjectReal->subscribe(...\func_get_args());
+        return $this->lazyObjectReal->subscribe($channels, $cb);
     }
 
     public function sunsubscribe($channels): \Redis|array|bool
     {
-        return $this->lazyObjectReal->sunsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->sunsubscribe($channels);
     }
 
     public function swapdb($src, $dst): \Redis|bool
     {
-        return $this->lazyObjectReal->swapdb(...\func_get_args());
+        return $this->lazyObjectReal->swapdb($src, $dst);
     }
 
     public function time(): \Redis|array
     {
-        return $this->lazyObjectReal->time(...\func_get_args());
+        return $this->lazyObjectReal->time();
     }
 
     public function ttl($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->ttl(...\func_get_args());
+        return $this->lazyObjectReal->ttl($key);
     }
 
     public function type($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->type(...\func_get_args());
+        return $this->lazyObjectReal->type($key);
     }
 
     public function unlink($key, ...$other_keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->unlink(...\func_get_args());
+        return $this->lazyObjectReal->unlink($key, ...$other_keys);
     }
 
     public function unsubscribe($channels): \Redis|array|bool
     {
-        return $this->lazyObjectReal->unsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->unsubscribe($channels);
     }
 
     public function unwatch(): \Redis|bool
     {
-        return $this->lazyObjectReal->unwatch(...\func_get_args());
+        return $this->lazyObjectReal->unwatch();
     }
 
     public function watch($key, ...$other_keys): \Redis|bool
     {
-        return $this->lazyObjectReal->watch(...\func_get_args());
+        return $this->lazyObjectReal->watch($key, ...$other_keys);
     }
 
     public function wait($numreplicas, $timeout): false|int
     {
-        return $this->lazyObjectReal->wait(...\func_get_args());
+        return $this->lazyObjectReal->wait($numreplicas, $timeout);
     }
 
     public function xack($key, $group, $ids): false|int
     {
-        return $this->lazyObjectReal->xack(...\func_get_args());
+        return $this->lazyObjectReal->xack($key, $group, $ids);
     }
 
     public function xadd($key, $id, $values, $maxlen = 0, $approx = false, $nomkstream = false): \Redis|false|string
     {
-        return $this->lazyObjectReal->xadd(...\func_get_args());
+        return $this->lazyObjectReal->xadd($key, $id, $values, $maxlen, $approx, $nomkstream);
     }
 
     public function xautoclaim($key, $group, $consumer, $min_idle, $start, $count = -1, $justid = false): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xautoclaim(...\func_get_args());
+        return $this->lazyObjectReal->xautoclaim($key, $group, $consumer, $min_idle, $start, $count, $justid);
     }
 
     public function xclaim($key, $group, $consumer, $min_idle, $ids, $options): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xclaim(...\func_get_args());
+        return $this->lazyObjectReal->xclaim($key, $group, $consumer, $min_idle, $ids, $options);
     }
 
     public function xdel($key, $ids): \Redis|false|int
     {
-        return $this->lazyObjectReal->xdel(...\func_get_args());
+        return $this->lazyObjectReal->xdel($key, $ids);
     }
 
     public function xgroup($operation, $key = null, $group = null, $id_or_consumer = null, $mkstream = false, $entries_read = -2): mixed
     {
-        return $this->lazyObjectReal->xgroup(...\func_get_args());
+        return $this->lazyObjectReal->xgroup($operation, $key, $group, $id_or_consumer, $mkstream, $entries_read);
     }
 
     public function xinfo($operation, $arg1 = null, $arg2 = null, $count = -1): mixed
     {
-        return $this->lazyObjectReal->xinfo(...\func_get_args());
+        return $this->lazyObjectReal->xinfo($operation, $arg1, $arg2, $count);
     }
 
     public function xlen($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->xlen(...\func_get_args());
+        return $this->lazyObjectReal->xlen($key);
     }
 
     public function xpending($key, $group, $start = null, $end = null, $count = -1, $consumer = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->xpending(...\func_get_args());
+        return $this->lazyObjectReal->xpending($key, $group, $start, $end, $count, $consumer);
     }
 
     public function xrange($key, $start, $end, $count = -1): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xrange(...\func_get_args());
+        return $this->lazyObjectReal->xrange($key, $start, $end, $count);
     }
 
     public function xread($streams, $count = -1, $block = -1): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xread(...\func_get_args());
+        return $this->lazyObjectReal->xread($streams, $count, $block);
     }
 
     public function xreadgroup($group, $consumer, $streams, $count = 1, $block = 1): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xreadgroup(...\func_get_args());
+        return $this->lazyObjectReal->xreadgroup($group, $consumer, $streams, $count, $block);
     }
 
     public function xrevrange($key, $end, $start, $count = -1): \Redis|array|bool
     {
-        return $this->lazyObjectReal->xrevrange(...\func_get_args());
+        return $this->lazyObjectReal->xrevrange($key, $end, $start, $count);
     }
 
     public function xtrim($key, $threshold, $approx = false, $minid = false, $limit = -1): \Redis|false|int
     {
-        return $this->lazyObjectReal->xtrim(...\func_get_args());
+        return $this->lazyObjectReal->xtrim($key, $threshold, $approx, $minid, $limit);
     }
 
     public function zAdd($key, $score_or_options, ...$more_scores_and_mems): \Redis|false|int
     {
-        return $this->lazyObjectReal->zAdd(...\func_get_args());
+        return $this->lazyObjectReal->zAdd($key, $score_or_options, ...$more_scores_and_mems);
     }
 
     public function zCard($key): \Redis|false|int
     {
-        return $this->lazyObjectReal->zCard(...\func_get_args());
+        return $this->lazyObjectReal->zCard($key);
     }
 
     public function zCount($key, $start, $end): \Redis|false|int
     {
-        return $this->lazyObjectReal->zCount(...\func_get_args());
+        return $this->lazyObjectReal->zCount($key, $start, $end);
     }
 
     public function zIncrBy($key, $value, $member): \Redis|false|float
     {
-        return $this->lazyObjectReal->zIncrBy(...\func_get_args());
+        return $this->lazyObjectReal->zIncrBy($key, $value, $member);
     }
 
     public function zLexCount($key, $min, $max): \Redis|false|int
     {
-        return $this->lazyObjectReal->zLexCount(...\func_get_args());
+        return $this->lazyObjectReal->zLexCount($key, $min, $max);
     }
 
     public function zMscore($key, $member, ...$other_members): \Redis|array|false
     {
-        return $this->lazyObjectReal->zMscore(...\func_get_args());
+        return $this->lazyObjectReal->zMscore($key, $member, ...$other_members);
     }
 
     public function zPopMax($key, $count = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zPopMax(...\func_get_args());
+        return $this->lazyObjectReal->zPopMax($key, $count);
     }
 
     public function zPopMin($key, $count = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zPopMin(...\func_get_args());
+        return $this->lazyObjectReal->zPopMin($key, $count);
     }
 
     public function zRange($key, $start, $end, $options = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRange(...\func_get_args());
+        return $this->lazyObjectReal->zRange($key, $start, $end, $options);
     }
 
     public function zRangeByLex($key, $min, $max, $offset = -1, $count = -1): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRangeByLex($key, $min, $max, $offset, $count);
     }
 
     public function zRangeByScore($key, $start, $end, $options = []): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRangeByScore($key, $start, $end, $options);
     }
 
     public function zrangestore($dstkey, $srckey, $start, $end, $options = null): \Redis|false|int
     {
-        return $this->lazyObjectReal->zrangestore(...\func_get_args());
+        return $this->lazyObjectReal->zrangestore($dstkey, $srckey, $start, $end, $options);
     }
 
     public function zRandMember($key, $options = null): \Redis|array|string
     {
-        return $this->lazyObjectReal->zRandMember(...\func_get_args());
+        return $this->lazyObjectReal->zRandMember($key, $options);
     }
 
     public function zRank($key, $member): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRank(...\func_get_args());
+        return $this->lazyObjectReal->zRank($key, $member);
     }
 
     public function zRem($key, $member, ...$other_members): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRem(...\func_get_args());
+        return $this->lazyObjectReal->zRem($key, $member, ...$other_members);
     }
 
     public function zRemRangeByLex($key, $min, $max): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRemRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByLex($key, $min, $max);
     }
 
     public function zRemRangeByRank($key, $start, $end): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRemRangeByRank(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByRank($key, $start, $end);
     }
 
     public function zRemRangeByScore($key, $start, $end): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRemRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRemRangeByScore($key, $start, $end);
     }
 
     public function zRevRange($key, $start, $end, $scores = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRevRange(...\func_get_args());
+        return $this->lazyObjectReal->zRevRange($key, $start, $end, $scores);
     }
 
     public function zRevRangeByLex($key, $max, $min, $offset = -1, $count = -1): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRevRangeByLex(...\func_get_args());
+        return $this->lazyObjectReal->zRevRangeByLex($key, $max, $min, $offset, $count);
     }
 
     public function zRevRangeByScore($key, $max, $min, $options = []): \Redis|array|false
     {
-        return $this->lazyObjectReal->zRevRangeByScore(...\func_get_args());
+        return $this->lazyObjectReal->zRevRangeByScore($key, $max, $min, $options);
     }
 
     public function zRevRank($key, $member): \Redis|false|int
     {
-        return $this->lazyObjectReal->zRevRank(...\func_get_args());
+        return $this->lazyObjectReal->zRevRank($key, $member);
     }
 
     public function zScore($key, $member): \Redis|false|float
     {
-        return $this->lazyObjectReal->zScore(...\func_get_args());
+        return $this->lazyObjectReal->zScore($key, $member);
     }
 
     public function zdiff($keys, $options = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zdiff(...\func_get_args());
+        return $this->lazyObjectReal->zdiff($keys, $options);
     }
 
     public function zdiffstore($dst, $keys): \Redis|false|int
     {
-        return $this->lazyObjectReal->zdiffstore(...\func_get_args());
+        return $this->lazyObjectReal->zdiffstore($dst, $keys);
     }
 
     public function zinter($keys, $weights = null, $options = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zinter(...\func_get_args());
+        return $this->lazyObjectReal->zinter($keys, $weights, $options);
     }
 
     public function zintercard($keys, $limit = -1): \Redis|false|int
     {
-        return $this->lazyObjectReal->zintercard(...\func_get_args());
+        return $this->lazyObjectReal->zintercard($keys, $limit);
     }
 
     public function zinterstore($dst, $keys, $weights = null, $aggregate = null): \Redis|false|int
     {
-        return $this->lazyObjectReal->zinterstore(...\func_get_args());
+        return $this->lazyObjectReal->zinterstore($dst, $keys, $weights, $aggregate);
     }
 
     public function zscan($key, &$iterator, $pattern = null, $count = 0): \Redis|array|false
     {
-        return $this->lazyObjectReal->zscan(...\func_get_args());
+        return $this->lazyObjectReal->zscan($key, $iterator, $pattern, $count);
     }
 
     public function zunion($keys, $weights = null, $options = null): \Redis|array|false
     {
-        return $this->lazyObjectReal->zunion(...\func_get_args());
+        return $this->lazyObjectReal->zunion($keys, $weights, $options);
     }
 
     public function zunionstore($dst, $keys, $weights = null, $aggregate = null): \Redis|false|int
     {
-        return $this->lazyObjectReal->zunionstore(...\func_get_args());
+        return $this->lazyObjectReal->zunionstore($dst, $keys, $weights, $aggregate);
     }
 }
diff --git a/src/Symfony/Component/Cache/Traits/RedisCluster5Proxy.php b/src/Symfony/Component/Cache/Traits/RedisCluster5Proxy.php
index d95aced028137..38b178dab71a3 100644
--- a/src/Symfony/Component/Cache/Traits/RedisCluster5Proxy.php
+++ b/src/Symfony/Component/Cache/Traits/RedisCluster5Proxy.php
@@ -36,951 +36,951 @@ class RedisCluster5Proxy extends \RedisCluster implements ResetInterface, LazyOb
 
     public function __construct($name, $seeds = null, $timeout = null, $read_timeout = null, $persistent = null, $auth = null)
     {
-        return $this->lazyObjectReal->__construct(...\func_get_args());
+        return $this->lazyObjectReal->__construct($name, $seeds, $timeout, $read_timeout, $persistent, $auth);
     }
 
     public function _masters()
     {
-        return $this->lazyObjectReal->_masters(...\func_get_args());
+        return $this->lazyObjectReal->_masters();
     }
 
     public function _prefix($key)
     {
-        return $this->lazyObjectReal->_prefix(...\func_get_args());
+        return $this->lazyObjectReal->_prefix($key);
     }
 
     public function _redir()
     {
-        return $this->lazyObjectReal->_redir(...\func_get_args());
+        return $this->lazyObjectReal->_redir();
     }
 
     public function _serialize($value)
     {
-        return $this->lazyObjectReal->_serialize(...\func_get_args());
+        return $this->lazyObjectReal->_serialize($value);
     }
 
     public function _unserialize($value)
     {
-        return $this->lazyObjectReal->_unserialize(...\func_get_args());
+        return $this->lazyObjectReal->_unserialize($value);
     }
 
     public function _compress($value)
     {
-        return $this->lazyObjectReal->_compress(...\func_get_args());
+        return $this->lazyObjectReal->_compress($value);
     }
 
     public function _uncompress($value)
     {
-        return $this->lazyObjectReal->_uncompress(...\func_get_args());
+        return $this->lazyObjectReal->_uncompress($value);
     }
 
     public function _pack($value)
     {
-        return $this->lazyObjectReal->_pack(...\func_get_args());
+        return $this->lazyObjectReal->_pack($value);
     }
 
     public function _unpack($value)
     {
-        return $this->lazyObjectReal->_unpack(...\func_get_args());
+        return $this->lazyObjectReal->_unpack($value);
     }
 
     public function acl($key_or_address, $subcmd, ...$args)
     {
-        return $this->lazyObjectReal->acl(...\func_get_args());
+        return $this->lazyObjectReal->acl($key_or_address, $subcmd, ...$args);
     }
 
     public function append($key, $value)
     {
-        return $this->lazyObjectReal->append(...\func_get_args());
+        return $this->lazyObjectReal->append($key, $value);
     }
 
     public function bgrewriteaof($key_or_address)
     {
-        return $this->lazyObjectReal->bgrewriteaof(...\func_get_args());
+        return $this->lazyObjectReal->bgrewriteaof($key_or_address);
     }
 
     public function bgsave($key_or_address)
     {
-        return $this->lazyObjectReal->bgsave(...\func_get_args());
+        return $this->lazyObjectReal->bgsave($key_or_address);
     }
 
     public function bitcount($key)
     {
-        return $this->lazyObjectReal->bitcount(...\func_get_args());
+        return $this->lazyObjectReal->bitcount($key);
     }
 
     public function bitop($operation, $ret_key, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->bitop(...\func_get_args());
+        return $this->lazyObjectReal->bitop($operation, $ret_key, $key, ...$other_keys);
     }
 
     public function bitpos($key, $bit, $start = null, $end = null)
     {
-        return $this->lazyObjectReal->bitpos(...\func_get_args());
+        return $this->lazyObjectReal->bitpos($key, $bit, $start, $end);
     }
 
     public function blpop($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->blpop(...\func_get_args());
+        return $this->lazyObjectReal->blpop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brpop($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->brpop(...\func_get_args());
+        return $this->lazyObjectReal->brpop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brpoplpush($src, $dst, $timeout)
     {
-        return $this->lazyObjectReal->brpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->brpoplpush($src, $dst, $timeout);
     }
 
     public function clearlasterror()
     {
-        return $this->lazyObjectReal->clearlasterror(...\func_get_args());
+        return $this->lazyObjectReal->clearlasterror();
     }
 
     public function bzpopmax($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->bzpopmax(...\func_get_args());
+        return $this->lazyObjectReal->bzpopmax($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzpopmin($key, $timeout_or_key, ...$extra_args)
     {
-        return $this->lazyObjectReal->bzpopmin(...\func_get_args());
+        return $this->lazyObjectReal->bzpopmin($key, $timeout_or_key, ...$extra_args);
     }
 
     public function client($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->client(...\func_get_args());
+        return $this->lazyObjectReal->client($key_or_address, $arg, ...$other_args);
     }
 
     public function close()
     {
-        return $this->lazyObjectReal->close(...\func_get_args());
+        return $this->lazyObjectReal->close();
     }
 
     public function cluster($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->cluster(...\func_get_args());
+        return $this->lazyObjectReal->cluster($key_or_address, $arg, ...$other_args);
     }
 
     public function command(...$args)
     {
-        return $this->lazyObjectReal->command(...\func_get_args());
+        return $this->lazyObjectReal->command(...$args);
     }
 
     public function config($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->config(...\func_get_args());
+        return $this->lazyObjectReal->config($key_or_address, $arg, ...$other_args);
     }
 
     public function dbsize($key_or_address)
     {
-        return $this->lazyObjectReal->dbsize(...\func_get_args());
+        return $this->lazyObjectReal->dbsize($key_or_address);
     }
 
     public function decr($key)
     {
-        return $this->lazyObjectReal->decr(...\func_get_args());
+        return $this->lazyObjectReal->decr($key);
     }
 
     public function decrby($key, $value)
     {
-        return $this->lazyObjectReal->decrby(...\func_get_args());
+        return $this->lazyObjectReal->decrby($key, $value);
     }
 
     public function del($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->del(...\func_get_args());
+        return $this->lazyObjectReal->del($key, ...$other_keys);
     }
 
     public function discard()
     {
-        return $this->lazyObjectReal->discard(...\func_get_args());
+        return $this->lazyObjectReal->discard();
     }
 
     public function dump($key)
     {
-        return $this->lazyObjectReal->dump(...\func_get_args());
+        return $this->lazyObjectReal->dump($key);
     }
 
     public function echo($msg)
     {
-        return $this->lazyObjectReal->echo(...\func_get_args());
+        return $this->lazyObjectReal->echo($msg);
     }
 
     public function eval($script, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->eval(...\func_get_args());
+        return $this->lazyObjectReal->eval($script, $args, $num_keys);
     }
 
     public function evalsha($script_sha, $args = null, $num_keys = null)
     {
-        return $this->lazyObjectReal->evalsha(...\func_get_args());
+        return $this->lazyObjectReal->evalsha($script_sha, $args, $num_keys);
     }
 
     public function exec()
     {
-        return $this->lazyObjectReal->exec(...\func_get_args());
+        return $this->lazyObjectReal->exec();
     }
 
     public function exists($key)
     {
-        return $this->lazyObjectReal->exists(...\func_get_args());
+        return $this->lazyObjectReal->exists($key);
     }
 
     public function expire($key, $timeout)
     {
-        return $this->lazyObjectReal->expire(...\func_get_args());
+        return $this->lazyObjectReal->expire($key, $timeout);
     }
 
     public function expireat($key, $timestamp)
     {
-        return $this->lazyObjectReal->expireat(...\func_get_args());
+        return $this->lazyObjectReal->expireat($key, $timestamp);
     }
 
     public function flushall($key_or_address, $async = null)
     {
-        return $this->lazyObjectReal->flushall(...\func_get_args());
+        return $this->lazyObjectReal->flushall($key_or_address, $async);
     }
 
     public function flushdb($key_or_address, $async = null)
     {
-        return $this->lazyObjectReal->flushdb(...\func_get_args());
+        return $this->lazyObjectReal->flushdb($key_or_address, $async);
     }
 
     public function geoadd($key, $lng, $lat, $member, ...$other_triples)
     {
-        return $this->lazyObjectReal->geoadd(...\func_get_args());
+        return $this->lazyObjectReal->geoadd($key, $lng, $lat, $member, ...$other_triples);
     }
 
     public function geodist($key, $src, $dst, $unit = null)
     {
-        return $this->lazyObjectReal->geodist(...\func_get_args());
+        return $this->lazyObjectReal->geodist($key, $src, $dst, $unit);
     }
 
     public function geohash($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->geohash(...\func_get_args());
+        return $this->lazyObjectReal->geohash($key, $member, ...$other_members);
     }
 
     public function geopos($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->geopos(...\func_get_args());
+        return $this->lazyObjectReal->geopos($key, $member, ...$other_members);
     }
 
     public function georadius($key, $lng, $lan, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadius(...\func_get_args());
+        return $this->lazyObjectReal->georadius($key, $lng, $lan, $radius, $unit, $opts);
     }
 
     public function georadius_ro($key, $lng, $lan, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadius_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadius_ro($key, $lng, $lan, $radius, $unit, $opts);
     }
 
     public function georadiusbymember($key, $member, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadiusbymember(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember($key, $member, $radius, $unit, $opts);
     }
 
     public function georadiusbymember_ro($key, $member, $radius, $unit, $opts = null)
     {
-        return $this->lazyObjectReal->georadiusbymember_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember_ro($key, $member, $radius, $unit, $opts);
     }
 
     public function get($key)
     {
-        return $this->lazyObjectReal->get(...\func_get_args());
+        return $this->lazyObjectReal->get($key);
     }
 
     public function getbit($key, $offset)
     {
-        return $this->lazyObjectReal->getbit(...\func_get_args());
+        return $this->lazyObjectReal->getbit($key, $offset);
     }
 
     public function getlasterror()
     {
-        return $this->lazyObjectReal->getlasterror(...\func_get_args());
+        return $this->lazyObjectReal->getlasterror();
     }
 
     public function getmode()
     {
-        return $this->lazyObjectReal->getmode(...\func_get_args());
+        return $this->lazyObjectReal->getmode();
     }
 
     public function getoption($option)
     {
-        return $this->lazyObjectReal->getoption(...\func_get_args());
+        return $this->lazyObjectReal->getoption($option);
     }
 
     public function getrange($key, $start, $end)
     {
-        return $this->lazyObjectReal->getrange(...\func_get_args());
+        return $this->lazyObjectReal->getrange($key, $start, $end);
     }
 
     public function getset($key, $value)
     {
-        return $this->lazyObjectReal->getset(...\func_get_args());
+        return $this->lazyObjectReal->getset($key, $value);
     }
 
     public function hdel($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->hdel(...\func_get_args());
+        return $this->lazyObjectReal->hdel($key, $member, ...$other_members);
     }
 
     public function hexists($key, $member)
     {
-        return $this->lazyObjectReal->hexists(...\func_get_args());
+        return $this->lazyObjectReal->hexists($key, $member);
     }
 
     public function hget($key, $member)
     {
-        return $this->lazyObjectReal->hget(...\func_get_args());
+        return $this->lazyObjectReal->hget($key, $member);
     }
 
     public function hgetall($key)
     {
-        return $this->lazyObjectReal->hgetall(...\func_get_args());
+        return $this->lazyObjectReal->hgetall($key);
     }
 
     public function hincrby($key, $member, $value)
     {
-        return $this->lazyObjectReal->hincrby(...\func_get_args());
+        return $this->lazyObjectReal->hincrby($key, $member, $value);
     }
 
     public function hincrbyfloat($key, $member, $value)
     {
-        return $this->lazyObjectReal->hincrbyfloat(...\func_get_args());
+        return $this->lazyObjectReal->hincrbyfloat($key, $member, $value);
     }
 
     public function hkeys($key)
     {
-        return $this->lazyObjectReal->hkeys(...\func_get_args());
+        return $this->lazyObjectReal->hkeys($key);
     }
 
     public function hlen($key)
     {
-        return $this->lazyObjectReal->hlen(...\func_get_args());
+        return $this->lazyObjectReal->hlen($key);
     }
 
     public function hmget($key, $keys)
     {
-        return $this->lazyObjectReal->hmget(...\func_get_args());
+        return $this->lazyObjectReal->hmget($key, $keys);
     }
 
     public function hmset($key, $pairs)
     {
-        return $this->lazyObjectReal->hmset(...\func_get_args());
+        return $this->lazyObjectReal->hmset($key, $pairs);
     }
 
     public function hscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->hscan(...\func_get_args());
+        return $this->lazyObjectReal->hscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function hset($key, $member, $value)
     {
-        return $this->lazyObjectReal->hset(...\func_get_args());
+        return $this->lazyObjectReal->hset($key, $member, $value);
     }
 
     public function hsetnx($key, $member, $value)
     {
-        return $this->lazyObjectReal->hsetnx(...\func_get_args());
+        return $this->lazyObjectReal->hsetnx($key, $member, $value);
     }
 
     public function hstrlen($key, $member)
     {
-        return $this->lazyObjectReal->hstrlen(...\func_get_args());
+        return $this->lazyObjectReal->hstrlen($key, $member);
     }
 
     public function hvals($key)
     {
-        return $this->lazyObjectReal->hvals(...\func_get_args());
+        return $this->lazyObjectReal->hvals($key);
     }
 
     public function incr($key)
     {
-        return $this->lazyObjectReal->incr(...\func_get_args());
+        return $this->lazyObjectReal->incr($key);
     }
 
     public function incrby($key, $value)
     {
-        return $this->lazyObjectReal->incrby(...\func_get_args());
+        return $this->lazyObjectReal->incrby($key, $value);
     }
 
     public function incrbyfloat($key, $value)
     {
-        return $this->lazyObjectReal->incrbyfloat(...\func_get_args());
+        return $this->lazyObjectReal->incrbyfloat($key, $value);
     }
 
     public function info($key_or_address, $option = null)
     {
-        return $this->lazyObjectReal->info(...\func_get_args());
+        return $this->lazyObjectReal->info($key_or_address, $option);
     }
 
     public function keys($pattern)
     {
-        return $this->lazyObjectReal->keys(...\func_get_args());
+        return $this->lazyObjectReal->keys($pattern);
     }
 
     public function lastsave($key_or_address)
     {
-        return $this->lazyObjectReal->lastsave(...\func_get_args());
+        return $this->lazyObjectReal->lastsave($key_or_address);
     }
 
     public function lget($key, $index)
     {
-        return $this->lazyObjectReal->lget(...\func_get_args());
+        return $this->lazyObjectReal->lget($key, $index);
     }
 
     public function lindex($key, $index)
     {
-        return $this->lazyObjectReal->lindex(...\func_get_args());
+        return $this->lazyObjectReal->lindex($key, $index);
     }
 
     public function linsert($key, $position, $pivot, $value)
     {
-        return $this->lazyObjectReal->linsert(...\func_get_args());
+        return $this->lazyObjectReal->linsert($key, $position, $pivot, $value);
     }
 
     public function llen($key)
     {
-        return $this->lazyObjectReal->llen(...\func_get_args());
+        return $this->lazyObjectReal->llen($key);
     }
 
     public function lpop($key)
     {
-        return $this->lazyObjectReal->lpop(...\func_get_args());
+        return $this->lazyObjectReal->lpop($key);
     }
 
     public function lpush($key, $value)
     {
-        return $this->lazyObjectReal->lpush(...\func_get_args());
+        return $this->lazyObjectReal->lpush($key, $value);
     }
 
     public function lpushx($key, $value)
     {
-        return $this->lazyObjectReal->lpushx(...\func_get_args());
+        return $this->lazyObjectReal->lpushx($key, $value);
     }
 
     public function lrange($key, $start, $end)
     {
-        return $this->lazyObjectReal->lrange(...\func_get_args());
+        return $this->lazyObjectReal->lrange($key, $start, $end);
     }
 
     public function lrem($key, $value)
     {
-        return $this->lazyObjectReal->lrem(...\func_get_args());
+        return $this->lazyObjectReal->lrem($key, $value);
     }
 
     public function lset($key, $index, $value)
     {
-        return $this->lazyObjectReal->lset(...\func_get_args());
+        return $this->lazyObjectReal->lset($key, $index, $value);
     }
 
     public function ltrim($key, $start, $stop)
     {
-        return $this->lazyObjectReal->ltrim(...\func_get_args());
+        return $this->lazyObjectReal->ltrim($key, $start, $stop);
     }
 
     public function mget($keys)
     {
-        return $this->lazyObjectReal->mget(...\func_get_args());
+        return $this->lazyObjectReal->mget($keys);
     }
 
     public function mset($pairs)
     {
-        return $this->lazyObjectReal->mset(...\func_get_args());
+        return $this->lazyObjectReal->mset($pairs);
     }
 
     public function msetnx($pairs)
     {
-        return $this->lazyObjectReal->msetnx(...\func_get_args());
+        return $this->lazyObjectReal->msetnx($pairs);
     }
 
     public function multi()
     {
-        return $this->lazyObjectReal->multi(...\func_get_args());
+        return $this->lazyObjectReal->multi();
     }
 
     public function object($field, $key)
     {
-        return $this->lazyObjectReal->object(...\func_get_args());
+        return $this->lazyObjectReal->object($field, $key);
     }
 
     public function persist($key)
     {
-        return $this->lazyObjectReal->persist(...\func_get_args());
+        return $this->lazyObjectReal->persist($key);
     }
 
     public function pexpire($key, $timestamp)
     {
-        return $this->lazyObjectReal->pexpire(...\func_get_args());
+        return $this->lazyObjectReal->pexpire($key, $timestamp);
     }
 
     public function pexpireat($key, $timestamp)
     {
-        return $this->lazyObjectReal->pexpireat(...\func_get_args());
+        return $this->lazyObjectReal->pexpireat($key, $timestamp);
     }
 
     public function pfadd($key, $elements)
     {
-        return $this->lazyObjectReal->pfadd(...\func_get_args());
+        return $this->lazyObjectReal->pfadd($key, $elements);
     }
 
     public function pfcount($key)
     {
-        return $this->lazyObjectReal->pfcount(...\func_get_args());
+        return $this->lazyObjectReal->pfcount($key);
     }
 
     public function pfmerge($dstkey, $keys)
     {
-        return $this->lazyObjectReal->pfmerge(...\func_get_args());
+        return $this->lazyObjectReal->pfmerge($dstkey, $keys);
     }
 
     public function ping($key_or_address)
     {
-        return $this->lazyObjectReal->ping(...\func_get_args());
+        return $this->lazyObjectReal->ping($key_or_address);
     }
 
     public function psetex($key, $expire, $value)
     {
-        return $this->lazyObjectReal->psetex(...\func_get_args());
+        return $this->lazyObjectReal->psetex($key, $expire, $value);
     }
 
     public function psubscribe($patterns, $callback)
     {
-        return $this->lazyObjectReal->psubscribe(...\func_get_args());
+        return $this->lazyObjectReal->psubscribe($patterns, $callback);
     }
 
     public function pttl($key)
     {
-        return $this->lazyObjectReal->pttl(...\func_get_args());
+        return $this->lazyObjectReal->pttl($key);
     }
 
     public function publish($channel, $message)
     {
-        return $this->lazyObjectReal->publish(...\func_get_args());
+        return $this->lazyObjectReal->publish($channel, $message);
     }
 
     public function pubsub($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->pubsub(...\func_get_args());
+        return $this->lazyObjectReal->pubsub($key_or_address, $arg, ...$other_args);
     }
 
     public function punsubscribe($pattern, ...$other_patterns)
     {
-        return $this->lazyObjectReal->punsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->punsubscribe($pattern, ...$other_patterns);
     }
 
     public function randomkey($key_or_address)
     {
-        return $this->lazyObjectReal->randomkey(...\func_get_args());
+        return $this->lazyObjectReal->randomkey($key_or_address);
     }
 
     public function rawcommand($cmd, ...$args)
     {
-        return $this->lazyObjectReal->rawcommand(...\func_get_args());
+        return $this->lazyObjectReal->rawcommand($cmd, ...$args);
     }
 
     public function rename($key, $newkey)
     {
-        return $this->lazyObjectReal->rename(...\func_get_args());
+        return $this->lazyObjectReal->rename($key, $newkey);
     }
 
     public function renamenx($key, $newkey)
     {
-        return $this->lazyObjectReal->renamenx(...\func_get_args());
+        return $this->lazyObjectReal->renamenx($key, $newkey);
     }
 
     public function restore($ttl, $key, $value)
     {
-        return $this->lazyObjectReal->restore(...\func_get_args());
+        return $this->lazyObjectReal->restore($ttl, $key, $value);
     }
 
     public function role()
     {
-        return $this->lazyObjectReal->role(...\func_get_args());
+        return $this->lazyObjectReal->role();
     }
 
     public function rpop($key)
     {
-        return $this->lazyObjectReal->rpop(...\func_get_args());
+        return $this->lazyObjectReal->rpop($key);
     }
 
     public function rpoplpush($src, $dst)
     {
-        return $this->lazyObjectReal->rpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->rpoplpush($src, $dst);
     }
 
     public function rpush($key, $value)
     {
-        return $this->lazyObjectReal->rpush(...\func_get_args());
+        return $this->lazyObjectReal->rpush($key, $value);
     }
 
     public function rpushx($key, $value)
     {
-        return $this->lazyObjectReal->rpushx(...\func_get_args());
+        return $this->lazyObjectReal->rpushx($key, $value);
     }
 
     public function sadd($key, $value)
     {
-        return $this->lazyObjectReal->sadd(...\func_get_args());
+        return $this->lazyObjectReal->sadd($key, $value);
     }
 
     public function saddarray($key, $options)
     {
-        return $this->lazyObjectReal->saddarray(...\func_get_args());
+        return $this->lazyObjectReal->saddarray($key, $options);
     }
 
     public function save($key_or_address)
     {
-        return $this->lazyObjectReal->save(...\func_get_args());
+        return $this->lazyObjectReal->save($key_or_address);
     }
 
     public function scan(&$i_iterator, $str_node, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->scan(...\func_get_args());
+        return $this->lazyObjectReal->scan($i_iterator, $str_node, $str_pattern, $i_count);
     }
 
     public function scard($key)
     {
-        return $this->lazyObjectReal->scard(...\func_get_args());
+        return $this->lazyObjectReal->scard($key);
     }
 
     public function script($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->script(...\func_get_args());
+        return $this->lazyObjectReal->script($key_or_address, $arg, ...$other_args);
     }
 
     public function sdiff($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sdiff(...\func_get_args());
+        return $this->lazyObjectReal->sdiff($key, ...$other_keys);
     }
 
     public function sdiffstore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sdiffstore(...\func_get_args());
+        return $this->lazyObjectReal->sdiffstore($dst, $key, ...$other_keys);
     }
 
     public function set($key, $value, $opts = null)
     {
-        return $this->lazyObjectReal->set(...\func_get_args());
+        return $this->lazyObjectReal->set($key, $value, $opts);
     }
 
     public function setbit($key, $offset, $value)
     {
-        return $this->lazyObjectReal->setbit(...\func_get_args());
+        return $this->lazyObjectReal->setbit($key, $offset, $value);
     }
 
     public function setex($key, $expire, $value)
     {
-        return $this->lazyObjectReal->setex(...\func_get_args());
+        return $this->lazyObjectReal->setex($key, $expire, $value);
     }
 
     public function setnx($key, $value)
     {
-        return $this->lazyObjectReal->setnx(...\func_get_args());
+        return $this->lazyObjectReal->setnx($key, $value);
     }
 
     public function setoption($option, $value)
     {
-        return $this->lazyObjectReal->setoption(...\func_get_args());
+        return $this->lazyObjectReal->setoption($option, $value);
     }
 
     public function setrange($key, $offset, $value)
     {
-        return $this->lazyObjectReal->setrange(...\func_get_args());
+        return $this->lazyObjectReal->setrange($key, $offset, $value);
     }
 
     public function sinter($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sinter(...\func_get_args());
+        return $this->lazyObjectReal->sinter($key, ...$other_keys);
     }
 
     public function sinterstore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sinterstore(...\func_get_args());
+        return $this->lazyObjectReal->sinterstore($dst, $key, ...$other_keys);
     }
 
     public function sismember($key, $value)
     {
-        return $this->lazyObjectReal->sismember(...\func_get_args());
+        return $this->lazyObjectReal->sismember($key, $value);
     }
 
     public function slowlog($key_or_address, $arg = null, ...$other_args)
     {
-        return $this->lazyObjectReal->slowlog(...\func_get_args());
+        return $this->lazyObjectReal->slowlog($key_or_address, $arg, ...$other_args);
     }
 
     public function smembers($key)
     {
-        return $this->lazyObjectReal->smembers(...\func_get_args());
+        return $this->lazyObjectReal->smembers($key);
     }
 
     public function smove($src, $dst, $value)
     {
-        return $this->lazyObjectReal->smove(...\func_get_args());
+        return $this->lazyObjectReal->smove($src, $dst, $value);
     }
 
     public function sort($key, $options = null)
     {
-        return $this->lazyObjectReal->sort(...\func_get_args());
+        return $this->lazyObjectReal->sort($key, $options);
     }
 
     public function spop($key)
     {
-        return $this->lazyObjectReal->spop(...\func_get_args());
+        return $this->lazyObjectReal->spop($key);
     }
 
     public function srandmember($key, $count = null)
     {
-        return $this->lazyObjectReal->srandmember(...\func_get_args());
+        return $this->lazyObjectReal->srandmember($key, $count);
     }
 
     public function srem($key, $value)
     {
-        return $this->lazyObjectReal->srem(...\func_get_args());
+        return $this->lazyObjectReal->srem($key, $value);
     }
 
     public function sscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->sscan(...\func_get_args());
+        return $this->lazyObjectReal->sscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function strlen($key)
     {
-        return $this->lazyObjectReal->strlen(...\func_get_args());
+        return $this->lazyObjectReal->strlen($key);
     }
 
     public function subscribe($channels, $callback)
     {
-        return $this->lazyObjectReal->subscribe(...\func_get_args());
+        return $this->lazyObjectReal->subscribe($channels, $callback);
     }
 
     public function sunion($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sunion(...\func_get_args());
+        return $this->lazyObjectReal->sunion($key, ...$other_keys);
     }
 
     public function sunionstore($dst, $key, ...$other_keys)
     {
-        return $this->lazyObjectReal->sunionstore(...\func_get_args());
+        return $this->lazyObjectReal->sunionstore($dst, $key, ...$other_keys);
     }
 
     public function time()
     {
-        return $this->lazyObjectReal->time(...\func_get_args());
+        return $this->lazyObjectReal->time();
     }
 
     public function ttl($key)
     {
-        return $this->lazyObjectReal->ttl(...\func_get_args());
+        return $this->lazyObjectReal->ttl($key);
     }
 
     public function type($key)
     {
-        return $this->lazyObjectReal->type(...\func_get_args());
+        return $this->lazyObjectReal->type($key);
     }
 
     public function unsubscribe($channel, ...$other_channels)
     {
-        return $this->lazyObjectReal->unsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->unsubscribe($channel, ...$other_channels);
     }
 
     public function unlink($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->unlink(...\func_get_args());
+        return $this->lazyObjectReal->unlink($key, ...$other_keys);
     }
 
     public function unwatch()
     {
-        return $this->lazyObjectReal->unwatch(...\func_get_args());
+        return $this->lazyObjectReal->unwatch();
     }
 
     public function watch($key, ...$other_keys)
     {
-        return $this->lazyObjectReal->watch(...\func_get_args());
+        return $this->lazyObjectReal->watch($key, ...$other_keys);
     }
 
     public function xack($str_key, $str_group, $arr_ids)
     {
-        return $this->lazyObjectReal->xack(...\func_get_args());
+        return $this->lazyObjectReal->xack($str_key, $str_group, $arr_ids);
     }
 
     public function xadd($str_key, $str_id, $arr_fields, $i_maxlen = null, $boo_approximate = null)
     {
-        return $this->lazyObjectReal->xadd(...\func_get_args());
+        return $this->lazyObjectReal->xadd($str_key, $str_id, $arr_fields, $i_maxlen, $boo_approximate);
     }
 
     public function xclaim($str_key, $str_group, $str_consumer, $i_min_idle, $arr_ids, $arr_opts = null)
     {
-        return $this->lazyObjectReal->xclaim(...\func_get_args());
+        return $this->lazyObjectReal->xclaim($str_key, $str_group, $str_consumer, $i_min_idle, $arr_ids, $arr_opts);
     }
 
     public function xdel($str_key, $arr_ids)
     {
-        return $this->lazyObjectReal->xdel(...\func_get_args());
+        return $this->lazyObjectReal->xdel($str_key, $arr_ids);
     }
 
     public function xgroup($str_operation, $str_key = null, $str_arg1 = null, $str_arg2 = null, $str_arg3 = null)
     {
-        return $this->lazyObjectReal->xgroup(...\func_get_args());
+        return $this->lazyObjectReal->xgroup($str_operation, $str_key, $str_arg1, $str_arg2, $str_arg3);
     }
 
     public function xinfo($str_cmd, $str_key = null, $str_group = null)
     {
-        return $this->lazyObjectReal->xinfo(...\func_get_args());
+        return $this->lazyObjectReal->xinfo($str_cmd, $str_key, $str_group);
     }
 
     public function xlen($key)
     {
-        return $this->lazyObjectReal->xlen(...\func_get_args());
+        return $this->lazyObjectReal->xlen($key);
     }
 
     public function xpending($str_key, $str_group, $str_start = null, $str_end = null, $i_count = null, $str_consumer = null)
     {
-        return $this->lazyObjectReal->xpending(...\func_get_args());
+        return $this->lazyObjectReal->xpending($str_key, $str_group, $str_start, $str_end, $i_count, $str_consumer);
     }
 
     public function xrange($str_key, $str_start, $str_end, $i_count = null)
     {
-        return $this->lazyObjectReal->xrange(...\func_get_args());
+        return $this->lazyObjectReal->xrange($str_key, $str_start, $str_end, $i_count);
     }
 
     public function xread($arr_streams, $i_count = null, $i_block = null)
     {
-        return $this->lazyObjectReal->xread(...\func_get_args());
+        return $this->lazyObjectReal->xread($arr_streams, $i_count, $i_block);
     }
 
     public function xreadgroup($str_group, $str_consumer, $arr_streams, $i_count = null, $i_block = null)
     {
-        return $this->lazyObjectReal->xreadgroup(...\func_get_args());
+        return $this->lazyObjectReal->xreadgroup($str_group, $str_consumer, $arr_streams, $i_count, $i_block);
     }
 
     public function xrevrange($str_key, $str_start, $str_end, $i_count = null)
     {
-        return $this->lazyObjectReal->xrevrange(...\func_get_args());
+        return $this->lazyObjectReal->xrevrange($str_key, $str_start, $str_end, $i_count);
     }
 
     public function xtrim($str_key, $i_maxlen, $boo_approximate = null)
     {
-        return $this->lazyObjectReal->xtrim(...\func_get_args());
+        return $this->lazyObjectReal->xtrim($str_key, $i_maxlen, $boo_approximate);
     }
 
     public function zadd($key, $score, $value, ...$extra_args)
     {
-        return $this->lazyObjectReal->zadd(...\func_get_args());
+        return $this->lazyObjectReal->zadd($key, $score, $value, ...$extra_args);
     }
 
     public function zcard($key)
     {
-        return $this->lazyObjectReal->zcard(...\func_get_args());
+        return $this->lazyObjectReal->zcard($key);
     }
 
     public function zcount($key, $min, $max)
     {
-        return $this->lazyObjectReal->zcount(...\func_get_args());
+        return $this->lazyObjectReal->zcount($key, $min, $max);
     }
 
     public function zincrby($key, $value, $member)
     {
-        return $this->lazyObjectReal->zincrby(...\func_get_args());
+        return $this->lazyObjectReal->zincrby($key, $value, $member);
     }
 
     public function zinterstore($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zinterstore(...\func_get_args());
+        return $this->lazyObjectReal->zinterstore($key, $keys, $weights, $aggregate);
     }
 
     public function zlexcount($key, $min, $max)
     {
-        return $this->lazyObjectReal->zlexcount(...\func_get_args());
+        return $this->lazyObjectReal->zlexcount($key, $min, $max);
     }
 
     public function zpopmax($key)
     {
-        return $this->lazyObjectReal->zpopmax(...\func_get_args());
+        return $this->lazyObjectReal->zpopmax($key);
     }
 
     public function zpopmin($key)
     {
-        return $this->lazyObjectReal->zpopmin(...\func_get_args());
+        return $this->lazyObjectReal->zpopmin($key);
     }
 
     public function zrange($key, $start, $end, $scores = null)
     {
-        return $this->lazyObjectReal->zrange(...\func_get_args());
+        return $this->lazyObjectReal->zrange($key, $start, $end, $scores);
     }
 
     public function zrangebylex($key, $min, $max, $offset = null, $limit = null)
     {
-        return $this->lazyObjectReal->zrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zrangebylex($key, $min, $max, $offset, $limit);
     }
 
     public function zrangebyscore($key, $start, $end, $options = null)
     {
-        return $this->lazyObjectReal->zrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zrangebyscore($key, $start, $end, $options);
     }
 
     public function zrank($key, $member)
     {
-        return $this->lazyObjectReal->zrank(...\func_get_args());
+        return $this->lazyObjectReal->zrank($key, $member);
     }
 
     public function zrem($key, $member, ...$other_members)
     {
-        return $this->lazyObjectReal->zrem(...\func_get_args());
+        return $this->lazyObjectReal->zrem($key, $member, ...$other_members);
     }
 
     public function zremrangebylex($key, $min, $max)
     {
-        return $this->lazyObjectReal->zremrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebylex($key, $min, $max);
     }
 
     public function zremrangebyrank($key, $min, $max)
     {
-        return $this->lazyObjectReal->zremrangebyrank(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebyrank($key, $min, $max);
     }
 
     public function zremrangebyscore($key, $min, $max)
     {
-        return $this->lazyObjectReal->zremrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebyscore($key, $min, $max);
     }
 
     public function zrevrange($key, $start, $end, $scores = null)
     {
-        return $this->lazyObjectReal->zrevrange(...\func_get_args());
+        return $this->lazyObjectReal->zrevrange($key, $start, $end, $scores);
     }
 
     public function zrevrangebylex($key, $min, $max, $offset = null, $limit = null)
     {
-        return $this->lazyObjectReal->zrevrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zrevrangebylex($key, $min, $max, $offset, $limit);
     }
 
     public function zrevrangebyscore($key, $start, $end, $options = null)
     {
-        return $this->lazyObjectReal->zrevrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zrevrangebyscore($key, $start, $end, $options);
     }
 
     public function zrevrank($key, $member)
     {
-        return $this->lazyObjectReal->zrevrank(...\func_get_args());
+        return $this->lazyObjectReal->zrevrank($key, $member);
     }
 
     public function zscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
     {
-        return $this->lazyObjectReal->zscan(...\func_get_args());
+        return $this->lazyObjectReal->zscan($str_key, $i_iterator, $str_pattern, $i_count);
     }
 
     public function zscore($key, $member)
     {
-        return $this->lazyObjectReal->zscore(...\func_get_args());
+        return $this->lazyObjectReal->zscore($key, $member);
     }
 
     public function zunionstore($key, $keys, $weights = null, $aggregate = null)
     {
-        return $this->lazyObjectReal->zunionstore(...\func_get_args());
+        return $this->lazyObjectReal->zunionstore($key, $keys, $weights, $aggregate);
     }
 }
diff --git a/src/Symfony/Component/Cache/Traits/RedisCluster6Proxy.php b/src/Symfony/Component/Cache/Traits/RedisCluster6Proxy.php
index e94fa2b36711e..20d802652dc68 100644
--- a/src/Symfony/Component/Cache/Traits/RedisCluster6Proxy.php
+++ b/src/Symfony/Component/Cache/Traits/RedisCluster6Proxy.php
@@ -36,1111 +36,1111 @@ class RedisCluster6Proxy extends \RedisCluster implements ResetInterface, LazyOb
 
     public function __construct($name, $seeds = null, $timeout = 0, $read_timeout = 0, $persistent = false, #[\SensitiveParameter] $auth = null, $context = null)
     {
-        return $this->lazyObjectReal->__construct(...\func_get_args());
+        return $this->lazyObjectReal->__construct($name, $seeds, $timeout, $read_timeout, $persistent, $auth, $context);
     }
 
     public function _compress($value): string
     {
-        return $this->lazyObjectReal->_compress(...\func_get_args());
+        return $this->lazyObjectReal->_compress($value);
     }
 
     public function _uncompress($value): string
     {
-        return $this->lazyObjectReal->_uncompress(...\func_get_args());
+        return $this->lazyObjectReal->_uncompress($value);
     }
 
     public function _serialize($value): bool|string
     {
-        return $this->lazyObjectReal->_serialize(...\func_get_args());
+        return $this->lazyObjectReal->_serialize($value);
     }
 
     public function _unserialize($value): mixed
     {
-        return $this->lazyObjectReal->_unserialize(...\func_get_args());
+        return $this->lazyObjectReal->_unserialize($value);
     }
 
     public function _pack($value): string
     {
-        return $this->lazyObjectReal->_pack(...\func_get_args());
+        return $this->lazyObjectReal->_pack($value);
     }
 
     public function _unpack($value): mixed
     {
-        return $this->lazyObjectReal->_unpack(...\func_get_args());
+        return $this->lazyObjectReal->_unpack($value);
     }
 
     public function _prefix($key): bool|string
     {
-        return $this->lazyObjectReal->_prefix(...\func_get_args());
+        return $this->lazyObjectReal->_prefix($key);
     }
 
     public function _masters(): array
     {
-        return $this->lazyObjectReal->_masters(...\func_get_args());
+        return $this->lazyObjectReal->_masters();
     }
 
     public function _redir(): ?string
     {
-        return $this->lazyObjectReal->_redir(...\func_get_args());
+        return $this->lazyObjectReal->_redir();
     }
 
     public function acl($key_or_address, $subcmd, ...$args): mixed
     {
-        return $this->lazyObjectReal->acl(...\func_get_args());
+        return $this->lazyObjectReal->acl($key_or_address, $subcmd, ...$args);
     }
 
     public function append($key, $value): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->append(...\func_get_args());
+        return $this->lazyObjectReal->append($key, $value);
     }
 
     public function bgrewriteaof($key_or_address): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->bgrewriteaof(...\func_get_args());
+        return $this->lazyObjectReal->bgrewriteaof($key_or_address);
     }
 
     public function bgsave($key_or_address): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->bgsave(...\func_get_args());
+        return $this->lazyObjectReal->bgsave($key_or_address);
     }
 
     public function bitcount($key, $start = 0, $end = -1, $bybit = false): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->bitcount(...\func_get_args());
+        return $this->lazyObjectReal->bitcount($key, $start, $end, $bybit);
     }
 
     public function bitop($operation, $deskey, $srckey, ...$otherkeys): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->bitop(...\func_get_args());
+        return $this->lazyObjectReal->bitop($operation, $deskey, $srckey, ...$otherkeys);
     }
 
     public function bitpos($key, $bit, $start = 0, $end = -1, $bybit = false): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->bitpos(...\func_get_args());
+        return $this->lazyObjectReal->bitpos($key, $bit, $start, $end, $bybit);
     }
 
     public function blpop($key, $timeout_or_key, ...$extra_args): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->blpop(...\func_get_args());
+        return $this->lazyObjectReal->blpop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brpop($key, $timeout_or_key, ...$extra_args): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->brpop(...\func_get_args());
+        return $this->lazyObjectReal->brpop($key, $timeout_or_key, ...$extra_args);
     }
 
     public function brpoplpush($srckey, $deskey, $timeout): mixed
     {
-        return $this->lazyObjectReal->brpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->brpoplpush($srckey, $deskey, $timeout);
     }
 
     public function lmove($src, $dst, $wherefrom, $whereto): \Redis|false|string
     {
-        return $this->lazyObjectReal->lmove(...\func_get_args());
+        return $this->lazyObjectReal->lmove($src, $dst, $wherefrom, $whereto);
     }
 
     public function blmove($src, $dst, $wherefrom, $whereto, $timeout): \Redis|false|string
     {
-        return $this->lazyObjectReal->blmove(...\func_get_args());
+        return $this->lazyObjectReal->blmove($src, $dst, $wherefrom, $whereto, $timeout);
     }
 
     public function bzpopmax($key, $timeout_or_key, ...$extra_args): array
     {
-        return $this->lazyObjectReal->bzpopmax(...\func_get_args());
+        return $this->lazyObjectReal->bzpopmax($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzpopmin($key, $timeout_or_key, ...$extra_args): array
     {
-        return $this->lazyObjectReal->bzpopmin(...\func_get_args());
+        return $this->lazyObjectReal->bzpopmin($key, $timeout_or_key, ...$extra_args);
     }
 
     public function bzmpop($timeout, $keys, $from, $count = 1): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->bzmpop(...\func_get_args());
+        return $this->lazyObjectReal->bzmpop($timeout, $keys, $from, $count);
     }
 
     public function zmpop($keys, $from, $count = 1): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->zmpop(...\func_get_args());
+        return $this->lazyObjectReal->zmpop($keys, $from, $count);
     }
 
     public function blmpop($timeout, $keys, $from, $count = 1): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->blmpop(...\func_get_args());
+        return $this->lazyObjectReal->blmpop($timeout, $keys, $from, $count);
     }
 
     public function lmpop($keys, $from, $count = 1): \RedisCluster|array|false|null
     {
-        return $this->lazyObjectReal->lmpop(...\func_get_args());
+        return $this->lazyObjectReal->lmpop($keys, $from, $count);
     }
 
     public function clearlasterror(): bool
     {
-        return $this->lazyObjectReal->clearlasterror(...\func_get_args());
+        return $this->lazyObjectReal->clearlasterror();
     }
 
     public function client($key_or_address, $subcommand, $arg = null): array|bool|string
     {
-        return $this->lazyObjectReal->client(...\func_get_args());
+        return $this->lazyObjectReal->client($key_or_address, $subcommand, $arg);
     }
 
     public function close(): bool
     {
-        return $this->lazyObjectReal->close(...\func_get_args());
+        return $this->lazyObjectReal->close();
     }
 
     public function cluster($key_or_address, $command, ...$extra_args): mixed
     {
-        return $this->lazyObjectReal->cluster(...\func_get_args());
+        return $this->lazyObjectReal->cluster($key_or_address, $command, ...$extra_args);
     }
 
     public function command(...$extra_args): mixed
     {
-        return $this->lazyObjectReal->command(...\func_get_args());
+        return $this->lazyObjectReal->command(...$extra_args);
     }
 
     public function config($key_or_address, $subcommand, ...$extra_args): mixed
     {
-        return $this->lazyObjectReal->config(...\func_get_args());
+        return $this->lazyObjectReal->config($key_or_address, $subcommand, ...$extra_args);
     }
 
     public function dbsize($key_or_address): \RedisCluster|int
     {
-        return $this->lazyObjectReal->dbsize(...\func_get_args());
+        return $this->lazyObjectReal->dbsize($key_or_address);
     }
 
     public function copy($src, $dst, $options = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->copy(...\func_get_args());
+        return $this->lazyObjectReal->copy($src, $dst, $options);
     }
 
     public function decr($key, $by = 1): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->decr(...\func_get_args());
+        return $this->lazyObjectReal->decr($key, $by);
     }
 
     public function decrby($key, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->decrby(...\func_get_args());
+        return $this->lazyObjectReal->decrby($key, $value);
     }
 
     public function decrbyfloat($key, $value): float
     {
-        return $this->lazyObjectReal->decrbyfloat(...\func_get_args());
+        return $this->lazyObjectReal->decrbyfloat($key, $value);
     }
 
     public function del($key, ...$other_keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->del(...\func_get_args());
+        return $this->lazyObjectReal->del($key, ...$other_keys);
     }
 
     public function discard(): bool
     {
-        return $this->lazyObjectReal->discard(...\func_get_args());
+        return $this->lazyObjectReal->discard();
     }
 
     public function dump($key): \RedisCluster|false|string
     {
-        return $this->lazyObjectReal->dump(...\func_get_args());
+        return $this->lazyObjectReal->dump($key);
     }
 
     public function echo($key_or_address, $msg): \RedisCluster|false|string
     {
-        return $this->lazyObjectReal->echo(...\func_get_args());
+        return $this->lazyObjectReal->echo($key_or_address, $msg);
     }
 
     public function eval($script, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->eval(...\func_get_args());
+        return $this->lazyObjectReal->eval($script, $args, $num_keys);
     }
 
     public function eval_ro($script, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->eval_ro(...\func_get_args());
+        return $this->lazyObjectReal->eval_ro($script, $args, $num_keys);
     }
 
     public function evalsha($script_sha, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->evalsha(...\func_get_args());
+        return $this->lazyObjectReal->evalsha($script_sha, $args, $num_keys);
     }
 
     public function evalsha_ro($script_sha, $args = [], $num_keys = 0): mixed
     {
-        return $this->lazyObjectReal->evalsha_ro(...\func_get_args());
+        return $this->lazyObjectReal->evalsha_ro($script_sha, $args, $num_keys);
     }
 
     public function exec(): array|false
     {
-        return $this->lazyObjectReal->exec(...\func_get_args());
+        return $this->lazyObjectReal->exec();
     }
 
     public function exists($key, ...$other_keys): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->exists(...\func_get_args());
+        return $this->lazyObjectReal->exists($key, ...$other_keys);
     }
 
     public function touch($key, ...$other_keys): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->touch(...\func_get_args());
+        return $this->lazyObjectReal->touch($key, ...$other_keys);
     }
 
     public function expire($key, $timeout, $mode = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->expire(...\func_get_args());
+        return $this->lazyObjectReal->expire($key, $timeout, $mode);
     }
 
     public function expireat($key, $timestamp, $mode = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->expireat(...\func_get_args());
+        return $this->lazyObjectReal->expireat($key, $timestamp, $mode);
     }
 
     public function expiretime($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->expiretime(...\func_get_args());
+        return $this->lazyObjectReal->expiretime($key);
     }
 
     public function pexpiretime($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->pexpiretime(...\func_get_args());
+        return $this->lazyObjectReal->pexpiretime($key);
     }
 
     public function flushall($key_or_address, $async = false): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->flushall(...\func_get_args());
+        return $this->lazyObjectReal->flushall($key_or_address, $async);
     }
 
     public function flushdb($key_or_address, $async = false): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->flushdb(...\func_get_args());
+        return $this->lazyObjectReal->flushdb($key_or_address, $async);
     }
 
     public function geoadd($key, $lng, $lat, $member, ...$other_triples_and_options): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->geoadd(...\func_get_args());
+        return $this->lazyObjectReal->geoadd($key, $lng, $lat, $member, ...$other_triples_and_options);
     }
 
     public function geodist($key, $src, $dest, $unit = null): \RedisCluster|false|float
     {
-        return $this->lazyObjectReal->geodist(...\func_get_args());
+        return $this->lazyObjectReal->geodist($key, $src, $dest, $unit);
     }
 
     public function geohash($key, $member, ...$other_members): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->geohash(...\func_get_args());
+        return $this->lazyObjectReal->geohash($key, $member, ...$other_members);
     }
 
     public function geopos($key, $member, ...$other_members): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->geopos(...\func_get_args());
+        return $this->lazyObjectReal->geopos($key, $member, ...$other_members);
     }
 
     public function georadius($key, $lng, $lat, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadius(...\func_get_args());
+        return $this->lazyObjectReal->georadius($key, $lng, $lat, $radius, $unit, $options);
     }
 
     public function georadius_ro($key, $lng, $lat, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadius_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadius_ro($key, $lng, $lat, $radius, $unit, $options);
     }
 
     public function georadiusbymember($key, $member, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadiusbymember(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember($key, $member, $radius, $unit, $options);
     }
 
     public function georadiusbymember_ro($key, $member, $radius, $unit, $options = []): mixed
     {
-        return $this->lazyObjectReal->georadiusbymember_ro(...\func_get_args());
+        return $this->lazyObjectReal->georadiusbymember_ro($key, $member, $radius, $unit, $options);
     }
 
     public function geosearch($key, $position, $shape, $unit, $options = []): \RedisCluster|array
     {
-        return $this->lazyObjectReal->geosearch(...\func_get_args());
+        return $this->lazyObjectReal->geosearch($key, $position, $shape, $unit, $options);
     }
 
     public function geosearchstore($dst, $src, $position, $shape, $unit, $options = []): \RedisCluster|array|false|int
     {
-        return $this->lazyObjectReal->geosearchstore(...\func_get_args());
+        return $this->lazyObjectReal->geosearchstore($dst, $src, $position, $shape, $unit, $options);
     }
 
     public function get($key): mixed
     {
-        return $this->lazyObjectReal->get(...\func_get_args());
+        return $this->lazyObjectReal->get($key);
     }
 
     public function getbit($key, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->getbit(...\func_get_args());
+        return $this->lazyObjectReal->getbit($key, $value);
     }
 
     public function getlasterror(): ?string
     {
-        return $this->lazyObjectReal->getlasterror(...\func_get_args());
+        return $this->lazyObjectReal->getlasterror();
     }
 
     public function getmode(): int
     {
-        return $this->lazyObjectReal->getmode(...\func_get_args());
+        return $this->lazyObjectReal->getmode();
     }
 
     public function getoption($option): mixed
     {
-        return $this->lazyObjectReal->getoption(...\func_get_args());
+        return $this->lazyObjectReal->getoption($option);
     }
 
     public function getrange($key, $start, $end): \RedisCluster|false|string
     {
-        return $this->lazyObjectReal->getrange(...\func_get_args());
+        return $this->lazyObjectReal->getrange($key, $start, $end);
     }
 
     public function lcs($key1, $key2, $options = null): \RedisCluster|array|false|int|string
     {
-        return $this->lazyObjectReal->lcs(...\func_get_args());
+        return $this->lazyObjectReal->lcs($key1, $key2, $options);
     }
 
     public function getset($key, $value): \RedisCluster|bool|string
     {
-        return $this->lazyObjectReal->getset(...\func_get_args());
+        return $this->lazyObjectReal->getset($key, $value);
     }
 
     public function gettransferredbytes(): array|false
     {
-        return $this->lazyObjectReal->gettransferredbytes(...\func_get_args());
+        return $this->lazyObjectReal->gettransferredbytes();
     }
 
     public function cleartransferredbytes(): void
     {
-        $this->lazyObjectReal->cleartransferredbytes(...\func_get_args());
+        $this->lazyObjectReal->cleartransferredbytes();
     }
 
     public function hdel($key, $member, ...$other_members): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->hdel(...\func_get_args());
+        return $this->lazyObjectReal->hdel($key, $member, ...$other_members);
     }
 
     public function hexists($key, $member): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->hexists(...\func_get_args());
+        return $this->lazyObjectReal->hexists($key, $member);
     }
 
     public function hget($key, $member): mixed
     {
-        return $this->lazyObjectReal->hget(...\func_get_args());
+        return $this->lazyObjectReal->hget($key, $member);
     }
 
     public function hgetall($key): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->hgetall(...\func_get_args());
+        return $this->lazyObjectReal->hgetall($key);
     }
 
     public function hincrby($key, $member, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->hincrby(...\func_get_args());
+        return $this->lazyObjectReal->hincrby($key, $member, $value);
     }
 
     public function hincrbyfloat($key, $member, $value): \RedisCluster|false|float
     {
-        return $this->lazyObjectReal->hincrbyfloat(...\func_get_args());
+        return $this->lazyObjectReal->hincrbyfloat($key, $member, $value);
     }
 
     public function hkeys($key): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->hkeys(...\func_get_args());
+        return $this->lazyObjectReal->hkeys($key);
     }
 
     public function hlen($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->hlen(...\func_get_args());
+        return $this->lazyObjectReal->hlen($key);
     }
 
     public function hmget($key, $keys): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->hmget(...\func_get_args());
+        return $this->lazyObjectReal->hmget($key, $keys);
     }
 
     public function hmset($key, $key_values): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->hmset(...\func_get_args());
+        return $this->lazyObjectReal->hmset($key, $key_values);
     }
 
     public function hscan($key, &$iterator, $pattern = null, $count = 0): array|bool
     {
-        return $this->lazyObjectReal->hscan(...\func_get_args());
+        return $this->lazyObjectReal->hscan($key, $iterator, $pattern, $count);
     }
 
     public function hrandfield($key, $options = null): \RedisCluster|array|string
     {
-        return $this->lazyObjectReal->hrandfield(...\func_get_args());
+        return $this->lazyObjectReal->hrandfield($key, $options);
     }
 
     public function hset($key, $member, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->hset(...\func_get_args());
+        return $this->lazyObjectReal->hset($key, $member, $value);
     }
 
     public function hsetnx($key, $member, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->hsetnx(...\func_get_args());
+        return $this->lazyObjectReal->hsetnx($key, $member, $value);
     }
 
     public function hstrlen($key, $field): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->hstrlen(...\func_get_args());
+        return $this->lazyObjectReal->hstrlen($key, $field);
     }
 
     public function hvals($key): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->hvals(...\func_get_args());
+        return $this->lazyObjectReal->hvals($key);
     }
 
     public function incr($key, $by = 1): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->incr(...\func_get_args());
+        return $this->lazyObjectReal->incr($key, $by);
     }
 
     public function incrby($key, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->incrby(...\func_get_args());
+        return $this->lazyObjectReal->incrby($key, $value);
     }
 
     public function incrbyfloat($key, $value): \RedisCluster|false|float
     {
-        return $this->lazyObjectReal->incrbyfloat(...\func_get_args());
+        return $this->lazyObjectReal->incrbyfloat($key, $value);
     }
 
     public function info($key_or_address, ...$sections): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->info(...\func_get_args());
+        return $this->lazyObjectReal->info($key_or_address, ...$sections);
     }
 
     public function keys($pattern): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->keys(...\func_get_args());
+        return $this->lazyObjectReal->keys($pattern);
     }
 
     public function lastsave($key_or_address): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->lastsave(...\func_get_args());
+        return $this->lazyObjectReal->lastsave($key_or_address);
     }
 
     public function lget($key, $index): \RedisCluster|bool|string
     {
-        return $this->lazyObjectReal->lget(...\func_get_args());
+        return $this->lazyObjectReal->lget($key, $index);
     }
 
     public function lindex($key, $index): mixed
     {
-        return $this->lazyObjectReal->lindex(...\func_get_args());
+        return $this->lazyObjectReal->lindex($key, $index);
     }
 
     public function linsert($key, $pos, $pivot, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->linsert(...\func_get_args());
+        return $this->lazyObjectReal->linsert($key, $pos, $pivot, $value);
     }
 
     public function llen($key): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->llen(...\func_get_args());
+        return $this->lazyObjectReal->llen($key);
     }
 
     public function lpop($key, $count = 0): \RedisCluster|array|bool|string
     {
-        return $this->lazyObjectReal->lpop(...\func_get_args());
+        return $this->lazyObjectReal->lpop($key, $count);
     }
 
     public function lpos($key, $value, $options = null): \Redis|array|bool|int|null
     {
-        return $this->lazyObjectReal->lpos(...\func_get_args());
+        return $this->lazyObjectReal->lpos($key, $value, $options);
     }
 
     public function lpush($key, $value, ...$other_values): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->lpush(...\func_get_args());
+        return $this->lazyObjectReal->lpush($key, $value, ...$other_values);
     }
 
     public function lpushx($key, $value): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->lpushx(...\func_get_args());
+        return $this->lazyObjectReal->lpushx($key, $value);
     }
 
     public function lrange($key, $start, $end): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->lrange(...\func_get_args());
+        return $this->lazyObjectReal->lrange($key, $start, $end);
     }
 
     public function lrem($key, $value, $count = 0): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->lrem(...\func_get_args());
+        return $this->lazyObjectReal->lrem($key, $value, $count);
     }
 
     public function lset($key, $index, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->lset(...\func_get_args());
+        return $this->lazyObjectReal->lset($key, $index, $value);
     }
 
     public function ltrim($key, $start, $end): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->ltrim(...\func_get_args());
+        return $this->lazyObjectReal->ltrim($key, $start, $end);
     }
 
     public function mget($keys): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->mget(...\func_get_args());
+        return $this->lazyObjectReal->mget($keys);
     }
 
     public function mset($key_values): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->mset(...\func_get_args());
+        return $this->lazyObjectReal->mset($key_values);
     }
 
     public function msetnx($key_values): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->msetnx(...\func_get_args());
+        return $this->lazyObjectReal->msetnx($key_values);
     }
 
     public function multi($value = \Redis::MULTI): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->multi(...\func_get_args());
+        return $this->lazyObjectReal->multi($value);
     }
 
     public function object($subcommand, $key): \RedisCluster|false|int|string
     {
-        return $this->lazyObjectReal->object(...\func_get_args());
+        return $this->lazyObjectReal->object($subcommand, $key);
     }
 
     public function persist($key): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->persist(...\func_get_args());
+        return $this->lazyObjectReal->persist($key);
     }
 
     public function pexpire($key, $timeout, $mode = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->pexpire(...\func_get_args());
+        return $this->lazyObjectReal->pexpire($key, $timeout, $mode);
     }
 
     public function pexpireat($key, $timestamp, $mode = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->pexpireat(...\func_get_args());
+        return $this->lazyObjectReal->pexpireat($key, $timestamp, $mode);
     }
 
     public function pfadd($key, $elements): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->pfadd(...\func_get_args());
+        return $this->lazyObjectReal->pfadd($key, $elements);
     }
 
     public function pfcount($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->pfcount(...\func_get_args());
+        return $this->lazyObjectReal->pfcount($key);
     }
 
     public function pfmerge($key, $keys): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->pfmerge(...\func_get_args());
+        return $this->lazyObjectReal->pfmerge($key, $keys);
     }
 
     public function ping($key_or_address, $message = null): mixed
     {
-        return $this->lazyObjectReal->ping(...\func_get_args());
+        return $this->lazyObjectReal->ping($key_or_address, $message);
     }
 
     public function psetex($key, $timeout, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->psetex(...\func_get_args());
+        return $this->lazyObjectReal->psetex($key, $timeout, $value);
     }
 
     public function psubscribe($patterns, $callback): void
     {
-        $this->lazyObjectReal->psubscribe(...\func_get_args());
+        $this->lazyObjectReal->psubscribe($patterns, $callback);
     }
 
     public function pttl($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->pttl(...\func_get_args());
+        return $this->lazyObjectReal->pttl($key);
     }
 
     public function publish($channel, $message): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->publish(...\func_get_args());
+        return $this->lazyObjectReal->publish($channel, $message);
     }
 
     public function pubsub($key_or_address, ...$values): mixed
     {
-        return $this->lazyObjectReal->pubsub(...\func_get_args());
+        return $this->lazyObjectReal->pubsub($key_or_address, ...$values);
     }
 
     public function punsubscribe($pattern, ...$other_patterns): array|bool
     {
-        return $this->lazyObjectReal->punsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->punsubscribe($pattern, ...$other_patterns);
     }
 
     public function randomkey($key_or_address): \RedisCluster|bool|string
     {
-        return $this->lazyObjectReal->randomkey(...\func_get_args());
+        return $this->lazyObjectReal->randomkey($key_or_address);
     }
 
     public function rawcommand($key_or_address, $command, ...$args): mixed
     {
-        return $this->lazyObjectReal->rawcommand(...\func_get_args());
+        return $this->lazyObjectReal->rawcommand($key_or_address, $command, ...$args);
     }
 
     public function rename($key_src, $key_dst): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->rename(...\func_get_args());
+        return $this->lazyObjectReal->rename($key_src, $key_dst);
     }
 
     public function renamenx($key, $newkey): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->renamenx(...\func_get_args());
+        return $this->lazyObjectReal->renamenx($key, $newkey);
     }
 
     public function restore($key, $timeout, $value, $options = null): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->restore(...\func_get_args());
+        return $this->lazyObjectReal->restore($key, $timeout, $value, $options);
     }
 
     public function role($key_or_address): mixed
     {
-        return $this->lazyObjectReal->role(...\func_get_args());
+        return $this->lazyObjectReal->role($key_or_address);
     }
 
     public function rpop($key, $count = 0): \RedisCluster|array|bool|string
     {
-        return $this->lazyObjectReal->rpop(...\func_get_args());
+        return $this->lazyObjectReal->rpop($key, $count);
     }
 
     public function rpoplpush($src, $dst): \RedisCluster|bool|string
     {
-        return $this->lazyObjectReal->rpoplpush(...\func_get_args());
+        return $this->lazyObjectReal->rpoplpush($src, $dst);
     }
 
     public function rpush($key, ...$elements): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->rpush(...\func_get_args());
+        return $this->lazyObjectReal->rpush($key, ...$elements);
     }
 
     public function rpushx($key, $value): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->rpushx(...\func_get_args());
+        return $this->lazyObjectReal->rpushx($key, $value);
     }
 
     public function sadd($key, $value, ...$other_values): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->sadd(...\func_get_args());
+        return $this->lazyObjectReal->sadd($key, $value, ...$other_values);
     }
 
     public function saddarray($key, $values): \RedisCluster|bool|int
     {
-        return $this->lazyObjectReal->saddarray(...\func_get_args());
+        return $this->lazyObjectReal->saddarray($key, $values);
     }
 
     public function save($key_or_address): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->save(...\func_get_args());
+        return $this->lazyObjectReal->save($key_or_address);
     }
 
     public function scan(&$iterator, $key_or_address, $pattern = null, $count = 0): array|bool
     {
-        return $this->lazyObjectReal->scan(...\func_get_args());
+        return $this->lazyObjectReal->scan($iterator, $key_or_address, $pattern, $count);
     }
 
     public function scard($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->scard(...\func_get_args());
+        return $this->lazyObjectReal->scard($key);
     }
 
     public function script($key_or_address, ...$args): mixed
     {
-        return $this->lazyObjectReal->script(...\func_get_args());
+        return $this->lazyObjectReal->script($key_or_address, ...$args);
     }
 
     public function sdiff($key, ...$other_keys): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->sdiff(...\func_get_args());
+        return $this->lazyObjectReal->sdiff($key, ...$other_keys);
     }
 
     public function sdiffstore($dst, $key, ...$other_keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->sdiffstore(...\func_get_args());
+        return $this->lazyObjectReal->sdiffstore($dst, $key, ...$other_keys);
     }
 
     public function set($key, $value, $options = null): \RedisCluster|bool|string
     {
-        return $this->lazyObjectReal->set(...\func_get_args());
+        return $this->lazyObjectReal->set($key, $value, $options);
     }
 
     public function setbit($key, $offset, $onoff): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->setbit(...\func_get_args());
+        return $this->lazyObjectReal->setbit($key, $offset, $onoff);
     }
 
     public function setex($key, $expire, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->setex(...\func_get_args());
+        return $this->lazyObjectReal->setex($key, $expire, $value);
     }
 
     public function setnx($key, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->setnx(...\func_get_args());
+        return $this->lazyObjectReal->setnx($key, $value);
     }
 
     public function setoption($option, $value): bool
     {
-        return $this->lazyObjectReal->setoption(...\func_get_args());
+        return $this->lazyObjectReal->setoption($option, $value);
     }
 
     public function setrange($key, $offset, $value): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->setrange(...\func_get_args());
+        return $this->lazyObjectReal->setrange($key, $offset, $value);
     }
 
     public function sinter($key, ...$other_keys): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->sinter(...\func_get_args());
+        return $this->lazyObjectReal->sinter($key, ...$other_keys);
     }
 
     public function sintercard($keys, $limit = -1): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->sintercard(...\func_get_args());
+        return $this->lazyObjectReal->sintercard($keys, $limit);
     }
 
     public function sinterstore($key, ...$other_keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->sinterstore(...\func_get_args());
+        return $this->lazyObjectReal->sinterstore($key, ...$other_keys);
     }
 
     public function sismember($key, $value): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->sismember(...\func_get_args());
+        return $this->lazyObjectReal->sismember($key, $value);
     }
 
     public function smismember($key, $member, ...$other_members): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->smismember(...\func_get_args());
+        return $this->lazyObjectReal->smismember($key, $member, ...$other_members);
     }
 
     public function slowlog($key_or_address, ...$args): mixed
     {
-        return $this->lazyObjectReal->slowlog(...\func_get_args());
+        return $this->lazyObjectReal->slowlog($key_or_address, ...$args);
     }
 
     public function smembers($key): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->smembers(...\func_get_args());
+        return $this->lazyObjectReal->smembers($key);
     }
 
     public function smove($src, $dst, $member): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->smove(...\func_get_args());
+        return $this->lazyObjectReal->smove($src, $dst, $member);
     }
 
     public function sort($key, $options = null): \RedisCluster|array|bool|int|string
     {
-        return $this->lazyObjectReal->sort(...\func_get_args());
+        return $this->lazyObjectReal->sort($key, $options);
     }
 
     public function sort_ro($key, $options = null): \RedisCluster|array|bool|int|string
     {
-        return $this->lazyObjectReal->sort_ro(...\func_get_args());
+        return $this->lazyObjectReal->sort_ro($key, $options);
     }
 
     public function spop($key, $count = 0): \RedisCluster|array|false|string
     {
-        return $this->lazyObjectReal->spop(...\func_get_args());
+        return $this->lazyObjectReal->spop($key, $count);
     }
 
     public function srandmember($key, $count = 0): \RedisCluster|array|false|string
     {
-        return $this->lazyObjectReal->srandmember(...\func_get_args());
+        return $this->lazyObjectReal->srandmember($key, $count);
     }
 
     public function srem($key, $value, ...$other_values): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->srem(...\func_get_args());
+        return $this->lazyObjectReal->srem($key, $value, ...$other_values);
     }
 
     public function sscan($key, &$iterator, $pattern = null, $count = 0): array|false
     {
-        return $this->lazyObjectReal->sscan(...\func_get_args());
+        return $this->lazyObjectReal->sscan($key, $iterator, $pattern, $count);
     }
 
     public function strlen($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->strlen(...\func_get_args());
+        return $this->lazyObjectReal->strlen($key);
     }
 
     public function subscribe($channels, $cb): void
     {
-        $this->lazyObjectReal->subscribe(...\func_get_args());
+        $this->lazyObjectReal->subscribe($channels, $cb);
     }
 
     public function sunion($key, ...$other_keys): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->sunion(...\func_get_args());
+        return $this->lazyObjectReal->sunion($key, ...$other_keys);
     }
 
     public function sunionstore($dst, $key, ...$other_keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->sunionstore(...\func_get_args());
+        return $this->lazyObjectReal->sunionstore($dst, $key, ...$other_keys);
     }
 
     public function time($key_or_address): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->time(...\func_get_args());
+        return $this->lazyObjectReal->time($key_or_address);
     }
 
     public function ttl($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->ttl(...\func_get_args());
+        return $this->lazyObjectReal->ttl($key);
     }
 
     public function type($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->type(...\func_get_args());
+        return $this->lazyObjectReal->type($key);
     }
 
     public function unsubscribe($channels): array|bool
     {
-        return $this->lazyObjectReal->unsubscribe(...\func_get_args());
+        return $this->lazyObjectReal->unsubscribe($channels);
     }
 
     public function unlink($key, ...$other_keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->unlink(...\func_get_args());
+        return $this->lazyObjectReal->unlink($key, ...$other_keys);
     }
 
     public function unwatch(): bool
     {
-        return $this->lazyObjectReal->unwatch(...\func_get_args());
+        return $this->lazyObjectReal->unwatch();
     }
 
     public function watch($key, ...$other_keys): \RedisCluster|bool
     {
-        return $this->lazyObjectReal->watch(...\func_get_args());
+        return $this->lazyObjectReal->watch($key, ...$other_keys);
     }
 
     public function xack($key, $group, $ids): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->xack(...\func_get_args());
+        return $this->lazyObjectReal->xack($key, $group, $ids);
     }
 
     public function xadd($key, $id, $values, $maxlen = 0, $approx = false): \RedisCluster|false|string
     {
-        return $this->lazyObjectReal->xadd(...\func_get_args());
+        return $this->lazyObjectReal->xadd($key, $id, $values, $maxlen, $approx);
     }
 
     public function xclaim($key, $group, $consumer, $min_iddle, $ids, $options): \RedisCluster|array|false|string
     {
-        return $this->lazyObjectReal->xclaim(...\func_get_args());
+        return $this->lazyObjectReal->xclaim($key, $group, $consumer, $min_iddle, $ids, $options);
     }
 
     public function xdel($key, $ids): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->xdel(...\func_get_args());
+        return $this->lazyObjectReal->xdel($key, $ids);
     }
 
     public function xgroup($operation, $key = null, $group = null, $id_or_consumer = null, $mkstream = false, $entries_read = -2): mixed
     {
-        return $this->lazyObjectReal->xgroup(...\func_get_args());
+        return $this->lazyObjectReal->xgroup($operation, $key, $group, $id_or_consumer, $mkstream, $entries_read);
     }
 
     public function xautoclaim($key, $group, $consumer, $min_idle, $start, $count = -1, $justid = false): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->xautoclaim(...\func_get_args());
+        return $this->lazyObjectReal->xautoclaim($key, $group, $consumer, $min_idle, $start, $count, $justid);
     }
 
     public function xinfo($operation, $arg1 = null, $arg2 = null, $count = -1): mixed
     {
-        return $this->lazyObjectReal->xinfo(...\func_get_args());
+        return $this->lazyObjectReal->xinfo($operation, $arg1, $arg2, $count);
     }
 
     public function xlen($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->xlen(...\func_get_args());
+        return $this->lazyObjectReal->xlen($key);
     }
 
     public function xpending($key, $group, $start = null, $end = null, $count = -1, $consumer = null): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->xpending(...\func_get_args());
+        return $this->lazyObjectReal->xpending($key, $group, $start, $end, $count, $consumer);
     }
 
     public function xrange($key, $start, $end, $count = -1): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->xrange(...\func_get_args());
+        return $this->lazyObjectReal->xrange($key, $start, $end, $count);
     }
 
     public function xread($streams, $count = -1, $block = -1): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->xread(...\func_get_args());
+        return $this->lazyObjectReal->xread($streams, $count, $block);
     }
 
     public function xreadgroup($group, $consumer, $streams, $count = 1, $block = 1): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->xreadgroup(...\func_get_args());
+        return $this->lazyObjectReal->xreadgroup($group, $consumer, $streams, $count, $block);
     }
 
     public function xrevrange($key, $start, $end, $count = -1): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->xrevrange(...\func_get_args());
+        return $this->lazyObjectReal->xrevrange($key, $start, $end, $count);
     }
 
     public function xtrim($key, $maxlen, $approx = false, $minid = false, $limit = -1): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->xtrim(...\func_get_args());
+        return $this->lazyObjectReal->xtrim($key, $maxlen, $approx, $minid, $limit);
     }
 
     public function zadd($key, $score_or_options, ...$more_scores_and_mems): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zadd(...\func_get_args());
+        return $this->lazyObjectReal->zadd($key, $score_or_options, ...$more_scores_and_mems);
     }
 
     public function zcard($key): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zcard(...\func_get_args());
+        return $this->lazyObjectReal->zcard($key);
     }
 
     public function zcount($key, $start, $end): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zcount(...\func_get_args());
+        return $this->lazyObjectReal->zcount($key, $start, $end);
     }
 
     public function zincrby($key, $value, $member): \RedisCluster|false|float
     {
-        return $this->lazyObjectReal->zincrby(...\func_get_args());
+        return $this->lazyObjectReal->zincrby($key, $value, $member);
     }
 
     public function zinterstore($dst, $keys, $weights = null, $aggregate = null): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zinterstore(...\func_get_args());
+        return $this->lazyObjectReal->zinterstore($dst, $keys, $weights, $aggregate);
     }
 
     public function zintercard($keys, $limit = -1): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zintercard(...\func_get_args());
+        return $this->lazyObjectReal->zintercard($keys, $limit);
     }
 
     public function zlexcount($key, $min, $max): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zlexcount(...\func_get_args());
+        return $this->lazyObjectReal->zlexcount($key, $min, $max);
     }
 
     public function zpopmax($key, $value = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zpopmax(...\func_get_args());
+        return $this->lazyObjectReal->zpopmax($key, $value);
     }
 
     public function zpopmin($key, $value = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zpopmin(...\func_get_args());
+        return $this->lazyObjectReal->zpopmin($key, $value);
     }
 
     public function zrange($key, $start, $end, $options = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zrange(...\func_get_args());
+        return $this->lazyObjectReal->zrange($key, $start, $end, $options);
     }
 
     public function zrangestore($dstkey, $srckey, $start, $end, $options = null): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zrangestore(...\func_get_args());
+        return $this->lazyObjectReal->zrangestore($dstkey, $srckey, $start, $end, $options);
     }
 
     public function zrandmember($key, $options = null): \RedisCluster|array|string
     {
-        return $this->lazyObjectReal->zrandmember(...\func_get_args());
+        return $this->lazyObjectReal->zrandmember($key, $options);
     }
 
     public function zrangebylex($key, $min, $max, $offset = -1, $count = -1): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->zrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zrangebylex($key, $min, $max, $offset, $count);
     }
 
     public function zrangebyscore($key, $start, $end, $options = []): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->zrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zrangebyscore($key, $start, $end, $options);
     }
 
     public function zrank($key, $member): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zrank(...\func_get_args());
+        return $this->lazyObjectReal->zrank($key, $member);
     }
 
     public function zrem($key, $value, ...$other_values): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zrem(...\func_get_args());
+        return $this->lazyObjectReal->zrem($key, $value, ...$other_values);
     }
 
     public function zremrangebylex($key, $min, $max): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zremrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebylex($key, $min, $max);
     }
 
     public function zremrangebyrank($key, $min, $max): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zremrangebyrank(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebyrank($key, $min, $max);
     }
 
     public function zremrangebyscore($key, $min, $max): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zremrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zremrangebyscore($key, $min, $max);
     }
 
     public function zrevrange($key, $min, $max, $options = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zrevrange(...\func_get_args());
+        return $this->lazyObjectReal->zrevrange($key, $min, $max, $options);
     }
 
     public function zrevrangebylex($key, $min, $max, $options = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zrevrangebylex(...\func_get_args());
+        return $this->lazyObjectReal->zrevrangebylex($key, $min, $max, $options);
     }
 
     public function zrevrangebyscore($key, $min, $max, $options = null): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zrevrangebyscore(...\func_get_args());
+        return $this->lazyObjectReal->zrevrangebyscore($key, $min, $max, $options);
     }
 
     public function zrevrank($key, $member): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zrevrank(...\func_get_args());
+        return $this->lazyObjectReal->zrevrank($key, $member);
     }
 
     public function zscan($key, &$iterator, $pattern = null, $count = 0): \RedisCluster|array|bool
     {
-        return $this->lazyObjectReal->zscan(...\func_get_args());
+        return $this->lazyObjectReal->zscan($key, $iterator, $pattern, $count);
     }
 
     public function zscore($key, $member): \RedisCluster|false|float
     {
-        return $this->lazyObjectReal->zscore(...\func_get_args());
+        return $this->lazyObjectReal->zscore($key, $member);
     }
 
     public function zmscore($key, $member, ...$other_members): \Redis|array|false
     {
-        return $this->lazyObjectReal->zmscore(...\func_get_args());
+        return $this->lazyObjectReal->zmscore($key, $member, ...$other_members);
     }
 
     public function zunionstore($dst, $keys, $weights = null, $aggregate = null): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zunionstore(...\func_get_args());
+        return $this->lazyObjectReal->zunionstore($dst, $keys, $weights, $aggregate);
     }
 
     public function zinter($keys, $weights = null, $options = null): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->zinter(...\func_get_args());
+        return $this->lazyObjectReal->zinter($keys, $weights, $options);
     }
 
     public function zdiffstore($dst, $keys): \RedisCluster|false|int
     {
-        return $this->lazyObjectReal->zdiffstore(...\func_get_args());
+        return $this->lazyObjectReal->zdiffstore($dst, $keys);
     }
 
     public function zunion($keys, $weights = null, $options = null): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->zunion(...\func_get_args());
+        return $this->lazyObjectReal->zunion($keys, $weights, $options);
     }
 
     public function zdiff($keys, $options = null): \RedisCluster|array|false
     {
-        return $this->lazyObjectReal->zdiff(...\func_get_args());
+        return $this->lazyObjectReal->zdiff($keys, $options);
     }
 }