From 76b67fffbe03d229e48b4fdab6d5c2648d253aa4 Mon Sep 17 00:00:00 2001
From: Remi Collet <remi@remirepo.net>
Date: Wed, 2 Aug 2023 15:52:45 +0200
Subject: update to 6.0.0RC1

rename to php-pecl-redis6 for new API
disable test suite for SCL
open https://github.com/phpredis/phpredis/pull/2367 PHP 7.2 required
---
 REFLECTION | 3725 +++++++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 2324 insertions(+), 1401 deletions(-)

(limited to 'REFLECTION')

diff --git a/REFLECTION b/REFLECTION
index f3599f5..9593d5e 100644
--- a/REFLECTION
+++ b/REFLECTION
@@ -1,4 +1,4 @@
-Extension [ <persistent> extension #117 redis version 5.3.7 ] {
+Extension [ <persistent> extension #120 redis version 6.0.0RC1 ] {
 
   - Dependencies {
     Dependency [ igbinary (Required) ]
@@ -96,17 +96,20 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       Current = '0'
     }
     Entry [ redis.session.lock_retries <ALL> ]
-      Current = '10'
+      Current = '100'
     }
     Entry [ redis.session.lock_wait_time <ALL> ]
-      Current = '2000'
+      Current = '20000'
+    }
+    Entry [ redis.session.early_refresh <ALL> ]
+      Current = '0'
     }
   }
 
   - Classes [6] {
     Class [ <internal:redis> class Redis ] {
 
-      - Constants [48] {
+      - Constants [49] {
         Constant [ public int REDIS_NOT_FOUND ] { 0 }
         Constant [ public int REDIS_STRING ] { 1 }
         Constant [ public int REDIS_SET ] { 2 }
@@ -114,9 +117,9 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
         Constant [ public int REDIS_ZSET ] { 4 }
         Constant [ public int REDIS_HASH ] { 5 }
         Constant [ public int REDIS_STREAM ] { 6 }
-        Constant [ public int PIPELINE ] { 2 }
         Constant [ public int ATOMIC ] { 0 }
         Constant [ public int MULTI ] { 1 }
+        Constant [ public int PIPELINE ] { 2 }
         Constant [ public int OPT_SERIALIZER ] { 1 }
         Constant [ public int OPT_PREFIX ] { 2 }
         Constant [ public int OPT_READ_TIMEOUT ] { 3 }
@@ -133,7 +136,6 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
         Constant [ public int COMPRESSION_NONE ] { 0 }
         Constant [ public int COMPRESSION_LZF ] { 1 }
         Constant [ public int COMPRESSION_ZSTD ] { 2 }
-        Constant [ public int COMPRESSION_ZSTD_MIN ] { 1 }
         Constant [ public int COMPRESSION_ZSTD_DEFAULT ] { 3 }
         Constant [ public int COMPRESSION_ZSTD_MAX ] { 22 }
         Constant [ public int COMPRESSION_LZ4 ] { 3 }
@@ -142,8 +144,10 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
         Constant [ public int SCAN_NORETRY ] { 0 }
         Constant [ public int SCAN_PREFIX ] { 2 }
         Constant [ public int SCAN_NOPREFIX ] { 3 }
-        Constant [ public string AFTER ] { after }
         Constant [ public string BEFORE ] { before }
+        Constant [ public string AFTER ] { after }
+        Constant [ public string LEFT ] { left }
+        Constant [ public string RIGHT ] { right }
         Constant [ public int OPT_MAX_RETRIES ] { 11 }
         Constant [ public int OPT_BACKOFF_ALGORITHM ] { 12 }
         Constant [ public int BACKOFF_ALGORITHM_DEFAULT ] { 0 }
@@ -166,10 +170,11 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Properties [0] {
       }
 
-      - Methods [240] {
+      - Methods [254] {
         Method [ <internal:redis, ctor> public method __construct ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <optional> array $options = null ]
           }
         }
 
@@ -179,758 +184,1127 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
           }
         }
 
-        Method [ <internal:redis> public method _prefix ] {
+        Method [ <internal:redis> public method _compress ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _serialize ] {
+        Method [ <internal:redis> public method _uncompress ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _unserialize ] {
+        Method [ <internal:redis> public method _prefix ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _pack ] {
+        Method [ <internal:redis> public method _serialize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> mixed $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _unpack ] {
+        Method [ <internal:redis> public method _unserialize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ mixed ]
         }
 
-        Method [ <internal:redis> public method _compress ] {
+        Method [ <internal:redis> public method _pack ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> mixed $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _uncompress ] {
+        Method [ <internal:redis> public method _unpack ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method acl ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $subcmd ]
-            Parameter #1 [ <optional> ...$args ]
+            Parameter #0 [ <required> string $subcmd ]
+            Parameter #1 [ <optional> string ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method append ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method auth ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $auth ]
+            Parameter #0 [ <required> mixed $credentials ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method bgSave ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method bgrewriteaof ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method bitcount ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $start = 0 ]
+            Parameter #2 [ <optional> int $end = -1 ]
+            Parameter #3 [ <optional> bool $bybit = false ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method bitop ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $operation ]
-            Parameter #1 [ <required> $ret_key ]
-            Parameter #2 [ <required> $key ]
-            Parameter #3 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <required> string $deskey ]
+            Parameter #2 [ <required> string $srckey ]
+            Parameter #3 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method bitpos ] {
 
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $bit ]
-            Parameter #2 [ <optional> $start = <default> ]
-            Parameter #3 [ <optional> $end = <default> ]
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> bool $bit ]
+            Parameter #2 [ <optional> int $start = 0 ]
+            Parameter #3 [ <optional> int $end = -1 ]
+            Parameter #4 [ <optional> bool $bybit = false ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method blPop ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key_or_keys ]
+            Parameter #1 [ <required> string|int|float $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ Redis|array|false|null ]
         }
 
         Method [ <internal:redis> public method brPop ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key_or_keys ]
+            Parameter #1 [ <required> string|int|float $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ Redis|array|false|null ]
         }
 
         Method [ <internal:redis> public method brpoplpush ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
-            Parameter #2 [ <required> $timeout ]
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> int|float $timeout ]
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method bzPopMax ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method bzPopMin ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
+          }
+          - Return [ Redis|array|false ]
+        }
+
+        Method [ <internal:redis> public method bzmpop ] {
+
+          - Parameters [4] {
+            Parameter #0 [ <required> float $timeout ]
+            Parameter #1 [ <required> array $keys ]
+            Parameter #2 [ <required> string $from ]
+            Parameter #3 [ <optional> int $count = 1 ]
+          }
+          - Return [ Redis|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method zmpop ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <required> string $from ]
+            Parameter #2 [ <optional> int $count = 1 ]
+          }
+          - Return [ Redis|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method blmpop ] {
+
+          - Parameters [4] {
+            Parameter #0 [ <required> float $timeout ]
+            Parameter #1 [ <required> array $keys ]
+            Parameter #2 [ <required> string $from ]
+            Parameter #3 [ <optional> int $count = 1 ]
+          }
+          - Return [ Redis|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method lmpop ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <required> string $from ]
+            Parameter #2 [ <optional> int $count = 1 ]
           }
+          - Return [ Redis|array|false|null ]
         }
 
         Method [ <internal:redis> public method clearLastError ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method client ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <optional> ...$args ]
+            Parameter #0 [ <required> string $opt ]
+            Parameter #1 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method close ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method command ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <optional> ...$args ]
+          - Parameters [2] {
+            Parameter #0 [ <optional> string $opt = null ]
+            Parameter #1 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method config ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> $value = <default> ]
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> array|string|null $key_or_settings = NULL ]
+            Parameter #2 [ <optional> ?string $value = NULL ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method connect ] {
 
-          - Parameters [4] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $port = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
-            Parameter #3 [ <optional> $retry_interval = <default> ]
+          - Parameters [7] {
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <optional> int $port = 6379 ]
+            Parameter #2 [ <optional> float $timeout = 0 ]
+            Parameter #3 [ <optional> string $persistent_id = null ]
+            Parameter #4 [ <optional> int $retry_interval = 0 ]
+            Parameter #5 [ <optional> float $read_timeout = 0 ]
+            Parameter #6 [ <optional> array $context = null ]
+          }
+          - Return [ bool ]
+        }
+
+        Method [ <internal:redis> public method copy ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <optional> array $options = null ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method dbSize ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method debug ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|string ]
         }
 
         Method [ <internal:redis> public method decr ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $by = 1 ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method decrBy ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method del ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal, deprecated:redis> public method delete ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method discard ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method dump ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|string ]
         }
 
         Method [ <internal:redis> public method echo ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $msg ]
+            Parameter #0 [ <required> string $str ]
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method eval ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $script ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
+            Parameter #0 [ <required> string $script ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
           }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method eval_ro ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $script_sha ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
+          }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method evalsha ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $script_sha ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
+            Parameter #0 [ <required> string $sha1 ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
+          }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method evalsha_ro ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $sha1 ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method exec ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method exists ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> mixed $key ]
+            Parameter #1 [ <optional> mixed ...$other_keys ]
           }
+          - Return [ Redis|int|bool ]
         }
 
         Method [ <internal:redis> public method expire ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method expireAt ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timestamp ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
+          }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method failover ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <optional> ?array $to = null ]
+            Parameter #1 [ <optional> bool $abort = false ]
+            Parameter #2 [ <optional> int $timeout = 0 ]
+          }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method expiretime ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $key ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method pexpiretime ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $key ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method fcall ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $fn ]
+            Parameter #1 [ <optional> array $keys = [] ]
+            Parameter #2 [ <optional> array $args = [] ]
+          }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method fcall_ro ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $fn ]
+            Parameter #1 [ <optional> array $keys = [] ]
+            Parameter #2 [ <optional> array $args = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method flushAll ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $async = <default> ]
+            Parameter #0 [ <optional> ?bool $sync = null ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method flushDB ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $async = <default> ]
+            Parameter #0 [ <optional> ?bool $sync = null ]
           }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method function ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> mixed ...$args ]
+          }
+          - Return [ Redis|array|string|bool ]
         }
 
         Method [ <internal:redis> public method geoadd ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lat ]
-            Parameter #3 [ <required> $member ]
-            Parameter #4 [ <optional> ...$other_triples ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> string $member ]
+            Parameter #4 [ <optional> mixed ...$other_triples_and_options ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method geodist ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $src ]
-            Parameter #2 [ <required> $dst ]
-            Parameter #3 [ <optional> $unit = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $src ]
+            Parameter #2 [ <required> string $dst ]
+            Parameter #3 [ <optional> ?string $unit = null ]
           }
+          - Return [ Redis|float|false ]
         }
 
         Method [ <internal:redis> public method geohash ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method geopos ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method georadius ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lan ]
-            Parameter #3 [ <required> $radius ]
-            Parameter #4 [ <required> $unit ]
-            Parameter #5 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> float $radius ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadius_ro ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lan ]
-            Parameter #3 [ <required> $radius ]
-            Parameter #4 [ <required> $unit ]
-            Parameter #5 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> float $radius ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadiusbymember ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $radius ]
-            Parameter #3 [ <required> $unit ]
-            Parameter #4 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> float $radius ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadiusbymember_ro ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $radius ]
-            Parameter #3 [ <required> $unit ]
-            Parameter #4 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> float $radius ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
+          }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method geosearch ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array|string $position ]
+            Parameter #2 [ <required> array|int|float $shape ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
+          }
+          - Return [ array ]
+        }
+
+        Method [ <internal:redis> public method geosearchstore ] {
+
+          - Parameters [6] {
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $src ]
+            Parameter #2 [ <required> array|string $position ]
+            Parameter #3 [ <required> array|int|float $shape ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
           }
+          - Return [ Redis|array|int|false ]
         }
 
         Method [ <internal:redis> public method get ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method getAuth ] {
 
           - Parameters [0] {
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method getBit ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $idx ]
           }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method getEx ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> array $options = [] ]
+          }
+          - Return [ Redis|string|bool ]
         }
 
         Method [ <internal:redis> public method getDBNum ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
+        }
+
+        Method [ <internal:redis> public method getDel ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $key ]
+          }
+          - Return [ Redis|string|bool ]
         }
 
         Method [ <internal:redis> public method getHost ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:redis> public method getLastError ] {
 
           - Parameters [0] {
           }
+          - Return [ ?string ]
         }
 
         Method [ <internal:redis> public method getMode ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:redis> public method getOption ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $option ]
+            Parameter #0 [ <required> int $option ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method getPersistentID ] {
 
           - Parameters [0] {
           }
+          - Return [ ?string ]
         }
 
         Method [ <internal:redis> public method getPort ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:redis> public method getRange ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
+          }
+          - Return [ Redis|string|false ]
+        }
+
+        Method [ <internal:redis> public method lcs ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key1 ]
+            Parameter #1 [ <required> string $key2 ]
+            Parameter #2 [ <optional> ?array $options = NULL ]
           }
+          - Return [ Redis|array|string|int|false ]
         }
 
         Method [ <internal:redis> public method getReadTimeout ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
-        Method [ <internal:redis> public method getSet ] {
+        Method [ <internal:redis> public method getset ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method getTimeout ] {
 
           - Parameters [0] {
           }
+          - Return [ float|false ]
+        }
+
+        Method [ <internal:redis> public method getTransferredBytes ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
+        }
+
+        Method [ <internal:redis> public method clearTransferredBytes ] {
+
+          - Parameters [0] {
+          }
+          - Return [ void ]
         }
 
         Method [ <internal:redis> public method hDel ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
+            Parameter #2 [ <optional> string ...$other_fields ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method hExists ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method hGet ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method hGetAll ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method hIncrBy ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
+            Parameter #2 [ <required> int $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method hIncrByFloat ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
+            Parameter #2 [ <required> float $value ]
           }
+          - Return [ Redis|float|false ]
         }
 
         Method [ <internal:redis> public method hKeys ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method hLen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method hMget ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $fields ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method hMset ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $pairs ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $fieldvals ]
           }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method hRandField ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> array $options = null ]
+          }
+          - Return [ Redis|array|string ]
         }
 
         Method [ <internal:redis> public method hSet ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method hSetNx ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
+            Parameter #2 [ <required> string $value ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method hStrLen ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method hVals ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method hscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method incr ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $by = 1 ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method incrBy ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method incrByFloat ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $value ]
           }
+          - Return [ Redis|float|false ]
         }
 
         Method [ <internal:redis> public method info ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $option = <default> ]
+            Parameter #0 [ <optional> string ...$sections ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method isConnected ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method keys ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pattern ]
+            Parameter #0 [ <required> string $pattern ]
           }
         }
 
         Method [ <internal:redis> public method lInsert ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $position ]
-            Parameter #2 [ <required> $pivot ]
-            Parameter #3 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $pos ]
+            Parameter #2 [ <required> mixed $pivot ]
+            Parameter #3 [ <required> mixed $value ]
           }
         }
 
         Method [ <internal:redis> public method lLen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method lMove ] {
+
+          - Parameters [4] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> string $wherefrom ]
+            Parameter #3 [ <required> string $whereto ]
+          }
+          - Return [ Redis|string|false ]
+        }
+
+        Method [ <internal:redis> public method blmove ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> string $wherefrom ]
+            Parameter #3 [ <required> string $whereto ]
+            Parameter #4 [ <required> float $timeout ]
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method lPop ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
+          }
+          - Return [ Redis|array|string|bool ]
+        }
+
+        Method [ <internal:redis> public method lPos ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> array $options = null ]
           }
+          - Return [ Redis|array|int|bool|null ]
         }
 
         Method [ <internal:redis> public method lPush ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> mixed ...$elements ]
           }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method rPush ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> mixed ...$elements ]
+          }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method lPushx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method rPushx ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method lSet ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method lastSave ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:redis> public method lindex ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method lrange ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method lrem ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <required> $count ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method ltrim ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $stop ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method mget ] {
@@ -938,1207 +1312,1251 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
           - Parameters [1] {
             Parameter #0 [ <required> array $keys ]
           }
+          - Return [ Redis|array ]
         }
 
         Method [ <internal:redis> public method migrate ] {
 
-          - Parameters [7] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <required> $port ]
-            Parameter #2 [ <required> $key ]
-            Parameter #3 [ <required> $db ]
-            Parameter #4 [ <required> $timeout ]
-            Parameter #5 [ <optional> $copy = <default> ]
-            Parameter #6 [ <optional> $replace = <default> ]
+          - Parameters [8] {
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <required> int $port ]
+            Parameter #2 [ <required> array|string $key ]
+            Parameter #3 [ <required> int $dstdb ]
+            Parameter #4 [ <required> int $timeout ]
+            Parameter #5 [ <optional> bool $copy = false ]
+            Parameter #6 [ <optional> bool $replace = false ]
+            Parameter #7 [ <optional> mixed $credentials = NULL ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method move ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $dbindex ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method mset ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> array $pairs ]
+            Parameter #0 [ <required> array $key_values ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method msetnx ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> array $pairs ]
+            Parameter #0 [ <required> array $key_values ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method multi ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $mode = <default> ]
+            Parameter #0 [ <optional> int $value = Redis::MULTI ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method object ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $field ]
-            Parameter #1 [ <required> $key ]
+            Parameter #0 [ <required> string $subcommand ]
+            Parameter #1 [ <required> string $key ]
           }
+          - Return [ Redis|string|int|false ]
+        }
+
+        Method [ <internal, deprecated:redis> public method open ] {
+
+          - Parameters [7] {
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <optional> int $port = 6379 ]
+            Parameter #2 [ <optional> float $timeout = 0 ]
+            Parameter #3 [ <optional> string $persistent_id = NULL ]
+            Parameter #4 [ <optional> int $retry_interval = 0 ]
+            Parameter #5 [ <optional> float $read_timeout = 0 ]
+            Parameter #6 [ <optional> array $context = NULL ]
+          }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method pconnect ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $port = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
+          - Parameters [7] {
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <optional> int $port = 6379 ]
+            Parameter #2 [ <optional> float $timeout = 0 ]
+            Parameter #3 [ <optional> string $persistent_id = NULL ]
+            Parameter #4 [ <optional> int $retry_interval = 0 ]
+            Parameter #5 [ <optional> float $read_timeout = 0 ]
+            Parameter #6 [ <optional> array $context = NULL ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method persist ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method pexpire ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method pexpireAt ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timestamp ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method pfadd ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
             Parameter #1 [ <required> array $elements ]
           }
+          - Return [ Redis|int ]
         }
 
         Method [ <internal:redis> public method pfcount ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> array|string $key_or_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method pfmerge ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $dstkey ]
-            Parameter #1 [ <required> array $keys ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> array $srckeys ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method ping ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <optional> string $message = NULL ]
           }
+          - Return [ Redis|string|bool ]
         }
 
         Method [ <internal:redis> public method pipeline ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal, deprecated:redis> public method popen ] {
+
+          - Parameters [7] {
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <optional> int $port = 6379 ]
+            Parameter #2 [ <optional> float $timeout = 0 ]
+            Parameter #3 [ <optional> string $persistent_id = NULL ]
+            Parameter #4 [ <optional> int $retry_interval = 0 ]
+            Parameter #5 [ <optional> float $read_timeout = 0 ]
+            Parameter #6 [ <optional> array $context = NULL ]
+          }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method psetex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $expire ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $expire ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method psubscribe ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> array $patterns ]
-            Parameter #1 [ <required> $callback ]
+            Parameter #1 [ <required> callable $cb ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method pttl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method publish ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $channel ]
-            Parameter #1 [ <required> $message ]
+            Parameter #0 [ <required> string $channel ]
+            Parameter #1 [ <required> string $message ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method pubsub ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <optional> ...$args ]
+            Parameter #0 [ <required> string $command ]
+            Parameter #1 [ <optional> mixed $arg = null ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method punsubscribe ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $pattern ]
-            Parameter #1 [ <optional> ...$other_patterns ]
-          }
-        }
-
-        Method [ <internal:redis> public method rPop ] {
-
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
-          }
-        }
-
-        Method [ <internal:redis> public method rPush ] {
-
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> array $patterns ]
           }
+          - Return [ Redis|array|bool ]
         }
 
-        Method [ <internal:redis> public method rPushx ] {
+        Method [ <internal:redis> public method rPop ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|array|string|bool ]
         }
 
         Method [ <internal:redis> public method randomKey ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method rawcommand ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <optional> ...$args ]
+            Parameter #0 [ <required> string $command ]
+            Parameter #1 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method rename ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $newkey ]
+            Parameter #0 [ <required> string $old_name ]
+            Parameter #1 [ <required> string $new_name ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method renameNx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $newkey ]
+            Parameter #0 [ <required> string $key_src ]
+            Parameter #1 [ <required> string $key_dst ]
+          }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method reset ] {
+
+          - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method restore ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $ttl ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <required> $value ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $ttl ]
+            Parameter #2 [ <required> string $value ]
+            Parameter #3 [ <optional> ?array $options = NULL ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method role ] {
 
           - Parameters [0] {
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method rpoplpush ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
+            Parameter #0 [ <required> string $srckey ]
+            Parameter #1 [ <required> string $dstkey ]
           }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method sAdd ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed ...$other_values ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method sAddArray ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $options ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $values ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:redis> public method sDiff ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method sDiffStore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $key ]
+            Parameter #2 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method sInter ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
+          }
+          - Return [ Redis|array|false ]
+        }
+
+        Method [ <internal:redis> public method sintercard ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> int $limit = -1 ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method sInterStore ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method sMembers ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method sMisMember ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method sMove ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method sPop ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|array|string|false ]
         }
 
         Method [ <internal:redis> public method sRandMember ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|array|string|false ]
         }
 
         Method [ <internal:redis> public method sUnion ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method sUnionStore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $key ]
+            Parameter #2 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method save ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method scan ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> &$i_iterator ]
-            Parameter #1 [ <optional> $str_pattern = <default> ]
-            Parameter #2 [ <optional> $i_count = <default> ]
+          - Parameters [4] {
+            Parameter #0 [ <required> ?int &$iterator ]
+            Parameter #1 [ <optional> ?string $pattern = null ]
+            Parameter #2 [ <optional> int $count = 0 ]
+            Parameter #3 [ <optional> string $type = NULL ]
           }
+          - Return [ array|false ]
         }
 
         Method [ <internal:redis> public method scard ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method script ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <optional> ...$args ]
+            Parameter #0 [ <required> string $command ]
+            Parameter #1 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method select ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $dbindex ]
+            Parameter #0 [ <required> int $db ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method set ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <optional> $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed $options = NULL ]
           }
+          - Return [ Redis|string|bool ]
         }
 
         Method [ <internal:redis> public method setBit ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $idx ]
+            Parameter #2 [ <required> bool $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
-        Method [ <internal:redis> public method setOption ] {
+        Method [ <internal:redis> public method setRange ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $option ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
+            Parameter #2 [ <required> string $value ]
           }
+          - Return [ Redis|int|false ]
         }
 
-        Method [ <internal:redis> public method setRange ] {
+        Method [ <internal:redis> public method setOption ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
-            Parameter #2 [ <required> $value ]
+          - Parameters [2] {
+            Parameter #0 [ <required> int $option ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method setex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $expire ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $expire ]
+            Parameter #2 [ <required> mixed $value ]
           }
         }
 
         Method [ <internal:redis> public method setnx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method sismember ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+          }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal, deprecated:redis> public method slaveof ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <optional> string $host = NULL ]
+            Parameter #1 [ <optional> int $port = 6379 ]
+          }
+          - Return [ Redis|bool ]
+        }
+
+        Method [ <internal:redis> public method replicaof ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <optional> string $host = NULL ]
+            Parameter #1 [ <optional> int $port = 6379 ]
           }
+          - Return [ Redis|bool ]
         }
 
-        Method [ <internal:redis> public method slaveof ] {
+        Method [ <internal:redis> public method touch ] {
 
           - Parameters [2] {
-            Parameter #0 [ <optional> $host = <default> ]
-            Parameter #1 [ <optional> $port = <default> ]
+            Parameter #0 [ <required> array|string $key_or_array ]
+            Parameter #1 [ <optional> string ...$more_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method slowlog ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $arg ]
-            Parameter #1 [ <optional> $option = <default> ]
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> int $length = 0 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method sort ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?array $options = null ]
           }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method sort_ro ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?array $options = null ]
+          }
+          - Return [ mixed ]
         }
 
         Method [ <internal, deprecated:redis> public method sortAsc ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $pattern = <default> ]
-            Parameter #2 [ <optional> $get = <default> ]
-            Parameter #3 [ <optional> $start = <default> ]
-            Parameter #4 [ <optional> $end = <default> ]
-            Parameter #5 [ <optional> $getList = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?string $pattern = null ]
+            Parameter #2 [ <optional> mixed $get = null ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $store = null ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal, deprecated:redis> public method sortAscAlpha ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $pattern = <default> ]
-            Parameter #2 [ <optional> $get = <default> ]
-            Parameter #3 [ <optional> $start = <default> ]
-            Parameter #4 [ <optional> $end = <default> ]
-            Parameter #5 [ <optional> $getList = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?string $pattern = null ]
+            Parameter #2 [ <optional> mixed $get = null ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $store = null ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal, deprecated:redis> public method sortDesc ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $pattern = <default> ]
-            Parameter #2 [ <optional> $get = <default> ]
-            Parameter #3 [ <optional> $start = <default> ]
-            Parameter #4 [ <optional> $end = <default> ]
-            Parameter #5 [ <optional> $getList = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?string $pattern = null ]
+            Parameter #2 [ <optional> mixed $get = null ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $store = null ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal, deprecated:redis> public method sortDescAlpha ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $pattern = <default> ]
-            Parameter #2 [ <optional> $get = <default> ]
-            Parameter #3 [ <optional> $start = <default> ]
-            Parameter #4 [ <optional> $end = <default> ]
-            Parameter #5 [ <optional> $getList = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?string $pattern = null ]
+            Parameter #2 [ <optional> mixed $get = null ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $store = null ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:redis> public method srem ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed ...$other_values ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method sscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
+          }
+          - Return [ array|false ]
+        }
+
+        Method [ <internal:redis> public method ssubscribe ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array $channels ]
+            Parameter #1 [ <required> callable $cb ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method strlen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method subscribe ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> array $channels ]
-            Parameter #1 [ <required> $callback ]
+            Parameter #1 [ <required> callable $cb ]
+          }
+          - Return [ bool ]
+        }
+
+        Method [ <internal:redis> public method sunsubscribe ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> array $channels ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method swapdb ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $srcdb ]
-            Parameter #1 [ <required> $dstdb ]
+            Parameter #0 [ <required> int $src ]
+            Parameter #1 [ <required> int $dst ]
           }
+          - Return [ Redis|bool ]
         }
 
         Method [ <internal:redis> public method time ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|array ]
         }
 
         Method [ <internal:redis> public method ttl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method type ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method unlink ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method unsubscribe ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $channel ]
-            Parameter #1 [ <optional> ...$other_channels ]
+          - Parameters [1] {
+            Parameter #0 [ <required> array $channels ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method unwatch ] {
 
           - Parameters [0] {
           }
+          - Return [ Redis|bool ]
         }
 
-        Method [ <internal:redis> public method wait ] {
+        Method [ <internal:redis> public method watch ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $numslaves ]
-            Parameter #1 [ <required> $timeout ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ Redis|bool ]
         }
 
-        Method [ <internal:redis> public method watch ] {
+        Method [ <internal:redis> public method wait ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> int $numreplicas ]
+            Parameter #1 [ <required> int $timeout ]
           }
+          - Return [ int|false ]
         }
 
         Method [ <internal:redis> public method xack ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <required> array $arr_ids ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> array $ids ]
           }
+          - Return [ int|false ]
         }
 
         Method [ <internal:redis> public method xadd ] {
 
-          - Parameters [5] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_id ]
-            Parameter #2 [ <required> array $arr_fields ]
-            Parameter #3 [ <optional> $i_maxlen = <default> ]
-            Parameter #4 [ <optional> $boo_approximate = <default> ]
+          - Parameters [6] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $id ]
+            Parameter #2 [ <required> array $values ]
+            Parameter #3 [ <optional> int $maxlen = 0 ]
+            Parameter #4 [ <optional> bool $approx = false ]
+            Parameter #5 [ <optional> bool $nomkstream = false ]
           }
+          - Return [ Redis|string|false ]
+        }
+
+        Method [ <internal:redis> public method xautoclaim ] {
+
+          - Parameters [7] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> string $consumer ]
+            Parameter #3 [ <required> int $min_idle ]
+            Parameter #4 [ <required> string $start ]
+            Parameter #5 [ <optional> int $count = -1 ]
+            Parameter #6 [ <optional> bool $justid = false ]
+          }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xclaim ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <required> $str_consumer ]
-            Parameter #3 [ <required> $i_min_idle ]
-            Parameter #4 [ <required> array $arr_ids ]
-            Parameter #5 [ <optional> array $arr_opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> string $consumer ]
+            Parameter #3 [ <required> int $min_idle ]
+            Parameter #4 [ <required> array $ids ]
+            Parameter #5 [ <required> array $options ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xdel ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> array $arr_ids ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $ids ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method xgroup ] {
 
-          - Parameters [5] {
-            Parameter #0 [ <required> $str_operation ]
-            Parameter #1 [ <optional> $str_key = <default> ]
-            Parameter #2 [ <optional> $str_arg1 = <default> ]
-            Parameter #3 [ <optional> $str_arg2 = <default> ]
-            Parameter #4 [ <optional> $str_arg3 = <default> ]
+          - Parameters [6] {
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> string $key = null ]
+            Parameter #2 [ <optional> string $group = null ]
+            Parameter #3 [ <optional> string $id_or_consumer = null ]
+            Parameter #4 [ <optional> bool $mkstream = false ]
+            Parameter #5 [ <optional> int $entries_read = -2 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method xinfo ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $str_cmd ]
-            Parameter #1 [ <optional> $str_key = <default> ]
-            Parameter #2 [ <optional> $str_group = <default> ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> ?string $arg1 = null ]
+            Parameter #2 [ <optional> ?string $arg2 = null ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method xlen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method xpending ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <optional> $str_start = <default> ]
-            Parameter #3 [ <optional> $str_end = <default> ]
-            Parameter #4 [ <optional> $i_count = <default> ]
-            Parameter #5 [ <optional> $str_consumer = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <optional> ?string $start = null ]
+            Parameter #3 [ <optional> ?string $end = null ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $consumer = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method xrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_start ]
-            Parameter #2 [ <required> $str_end ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xread ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> array $arr_streams ]
-            Parameter #1 [ <optional> $i_count = <default> ]
-            Parameter #2 [ <optional> $i_block = <default> ]
+            Parameter #0 [ <required> array $streams ]
+            Parameter #1 [ <optional> int $count = -1 ]
+            Parameter #2 [ <optional> int $block = -1 ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xreadgroup ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $str_group ]
-            Parameter #1 [ <required> $str_consumer ]
-            Parameter #2 [ <required> array $arr_streams ]
-            Parameter #3 [ <optional> $i_count = <default> ]
-            Parameter #4 [ <optional> $i_block = <default> ]
+            Parameter #0 [ <required> string $group ]
+            Parameter #1 [ <required> string $consumer ]
+            Parameter #2 [ <required> array $streams ]
+            Parameter #3 [ <optional> int $count = 1 ]
+            Parameter #4 [ <optional> int $block = 1 ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xrevrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_start ]
-            Parameter #2 [ <required> $str_end ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $end ]
+            Parameter #2 [ <required> string $start ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ Redis|array|bool ]
         }
 
         Method [ <internal:redis> public method xtrim ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $i_maxlen ]
-            Parameter #2 [ <optional> $boo_approximate = <default> ]
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $threshold ]
+            Parameter #2 [ <optional> bool $approx = false ]
+            Parameter #3 [ <optional> bool $minid = false ]
+            Parameter #4 [ <optional> int $limit = -1 ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zAdd ] {
 
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $score ]
-            Parameter #2 [ <required> $value ]
-            Parameter #3 [ <optional> ...$extra_args ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array|float $score_or_options ]
+            Parameter #2 [ <optional> mixed ...$more_scores_and_mems ]
           }
+          - Return [ Redis|int|float|false ]
         }
 
         Method [ <internal:redis> public method zCard ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zCount ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zIncrBy ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $value ]
+            Parameter #2 [ <required> mixed $member ]
           }
+          - Return [ Redis|float|false ]
         }
 
         Method [ <internal:redis> public method zLexCount ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method zMscore ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
+            Parameter #2 [ <optional> mixed ...$other_members ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zPopMax ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zPopMin ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> $scores = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string|int $start ]
+            Parameter #2 [ <required> string|int $end ]
+            Parameter #3 [ <optional> array|bool|null $options = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRangeByLex ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-            Parameter #3 [ <optional> $offset = <default> ]
-            Parameter #4 [ <optional> $limit = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRangeByScore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
+            Parameter #3 [ <optional> array $options = [] ]
+          }
+          - Return [ Redis|array|false ]
+        }
+
+        Method [ <internal:redis> public method zrangestore ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $dstkey ]
+            Parameter #1 [ <required> string $srckey ]
+            Parameter #2 [ <required> string $start ]
+            Parameter #3 [ <required> string $end ]
+            Parameter #4 [ <optional> array|bool|null $options = NULL ]
+          }
+          - Return [ Redis|int|false ]
+        }
+
+        Method [ <internal:redis> public method zRandMember ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> array $options = null ]
           }
+          - Return [ Redis|array|string ]
         }
 
         Method [ <internal:redis> public method zRank ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zRem ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> mixed $key ]
+            Parameter #1 [ <required> mixed $member ]
+            Parameter #2 [ <optional> mixed ...$other_members ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zRemRangeByLex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zRemRangeByRank ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zRemRangeByScore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zRevRange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> $scores = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
+            Parameter #3 [ <optional> mixed $scores = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRevRangeByLex ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-            Parameter #3 [ <optional> $offset = <default> ]
-            Parameter #4 [ <optional> $limit = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $max ]
+            Parameter #2 [ <required> string $min ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRevRangeByScore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $max ]
+            Parameter #2 [ <required> string $min ]
+            Parameter #3 [ <optional> array|bool $options = [] ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zRevRank ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
           }
+          - Return [ Redis|int|false ]
         }
 
         Method [ <internal:redis> public method zScore ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-          }
-        }
-
-        Method [ <internal:redis> public method zinterstore ] {
-
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
           }
+          - Return [ Redis|float|false ]
         }
 
-        Method [ <internal:redis> public method zscan ] {
-
-          - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
-          }
-        }
-
-        Method [ <internal:redis> public method zunionstore ] {
-
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method delete ] {
+        Method [ <internal:redis> public method zdiff ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method evaluate ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $script ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method evaluateSha ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $script_sha ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method getKeys ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $pattern ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method getMultiple ] {
-
-          - Parameters [1] {
             Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> array $options = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method lGet ] {
+        Method [ <internal:redis> public method zdiffstore ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method lGetRange ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method lRemove ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <required> $count ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method lSize ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method listTrim ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $stop ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method open ] {
-
-          - Parameters [4] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $port = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
-            Parameter #3 [ <optional> $retry_interval = <default> ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method popen ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $port = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method renameKey ] {
-
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $newkey ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method sContains ] {
-
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method sGetMembers ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> array $keys ]
           }
+          - Return [ Redis|int|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method sRemove ] {
+        Method [ <internal:redis> public method zinter ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method sSize ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method sendEcho ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $msg ]
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> ?array $weights = null ]
+            Parameter #2 [ <optional> ?array $options = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method setTimeout ] {
+        Method [ <internal:redis> public method zintercard ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method substr ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method zDelete ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method zDeleteRangeByRank ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method zDeleteRangeByScore ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> int $limit = -1 ]
           }
+          - Return [ Redis|int|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method zInter ] {
+        Method [ <internal:redis> public method zinterstore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $dst ]
             Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
+            Parameter #2 [ <optional> ?array $weights = null ]
+            Parameter #3 [ <optional> ?string $aggregate = null ]
           }
+          - Return [ Redis|int|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method zRemove ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method zRemoveRangeByScore ] {
-
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-          }
-        }
-
-        Method [ <internal, deprecated:redis> public method zReverseRange ] {
+        Method [ <internal:redis> public method zscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> $scores = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ Redis|array|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method zSize ] {
+        Method [ <internal:redis> public method zunion ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> ?array $weights = null ]
+            Parameter #2 [ <optional> ?array $options = null ]
           }
+          - Return [ Redis|array|false ]
         }
 
-        Method [ <internal, deprecated:redis> public method zUnion ] {
+        Method [ <internal:redis> public method zunionstore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $dst ]
             Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
+            Parameter #2 [ <optional> ?array $weights = NULL ]
+            Parameter #3 [ <optional> ?string $aggregate = NULL ]
           }
+          - Return [ Redis|int|false ]
         }
       }
     }
@@ -2157,20 +2575,21 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Properties [0] {
       }
 
-      - Methods [33] {
+      - Methods [31] {
         Method [ <internal:redis> public method __call ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $function_name ]
-            Parameter #1 [ <required> $arguments ]
+            Parameter #0 [ <required> string $function_name ]
+            Parameter #1 [ <required> array $arguments ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis, ctor> public method __construct ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $name_or_hosts ]
-            Parameter #1 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> array|string $name_or_hosts ]
+            Parameter #1 [ <optional> array $options = NULL ]
           }
         }
 
@@ -2178,278 +2597,247 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
 
           - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method _distributor ] {
 
           - Parameters [0] {
           }
+          - Return [ callable|bool ]
         }
 
         Method [ <internal:redis> public method _function ] {
 
           - Parameters [0] {
           }
+          - Return [ callable|bool ]
         }
 
         Method [ <internal:redis> public method _hosts ] {
 
           - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method _instance ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $host ]
+            Parameter #0 [ <required> string $host ]
           }
+          - Return [ Redis|bool|null ]
         }
 
         Method [ <internal:redis> public method _rehash ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $callable = <default> ]
+            Parameter #0 [ <optional> callable $fn = NULL ]
           }
+          - Return [ ?bool ]
         }
 
         Method [ <internal:redis> public method _target ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ string|bool|null ]
         }
 
         Method [ <internal:redis> public method bgsave ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:redis> public method del ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $keys ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$otherkeys ]
           }
+          - Return [ int|bool ]
         }
 
         Method [ <internal:redis> public method discard ] {
 
           - Parameters [0] {
           }
+          - Return [ ?bool ]
         }
 
         Method [ <internal:redis> public method exec ] {
 
           - Parameters [0] {
           }
+          - Return [ ?bool ]
         }
 
         Method [ <internal:redis> public method flushall ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <optional> $async = <default> ]
+          - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method flushdb ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <optional> $async = <default> ]
+          - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method getOption ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $opt ]
+            Parameter #0 [ <required> int $opt ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method hscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method info ] {
 
           - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method keys ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pattern ]
+            Parameter #0 [ <required> string $pattern ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method mget ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $keys ]
+            Parameter #0 [ <required> array $keys ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method mset ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pairs ]
+            Parameter #0 [ <required> array $pairs ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method multi ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $mode = <default> ]
+            Parameter #0 [ <required> string $host ]
+            Parameter #1 [ <optional> int $mode = NULL ]
           }
+          - Return [ RedisArray|bool ]
         }
 
         Method [ <internal:redis> public method ping ] {
 
           - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method save ] {
 
           - Parameters [0] {
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method scan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> &$iterator ]
-            Parameter #1 [ <required> $node ]
-            Parameter #2 [ <optional> $pattern = <default> ]
-            Parameter #3 [ <optional> $count = <default> ]
+            Parameter #0 [ <required> ?int &$iterator ]
+            Parameter #1 [ <required> string $node ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method select ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $index ]
+            Parameter #0 [ <required> int $index ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method setOption ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $opt ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> int $opt ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method sscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method unlink ] {
 
-          - Parameters [0] {
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$otherkeys ]
           }
+          - Return [ int|bool ]
         }
 
         Method [ <internal:redis> public method unwatch ] {
 
           - Parameters [0] {
           }
+          - Return [ ?bool ]
         }
 
         Method [ <internal:redis> public method zscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
-          }
-        }
-
-        Method [ <internal:redis> public method delete ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $keys ]
-          }
-        }
-
-        Method [ <internal:redis> public method getMultiple ] {
-
-          - Parameters [1] {
-            Parameter #0 [ <required> $keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|bool ]
         }
       }
     }
 
     Class [ <internal:redis> class RedisCluster ] {
 
-      - Constants [52] {
-        Constant [ public int REDIS_NOT_FOUND ] { 0 }
-        Constant [ public int REDIS_STRING ] { 1 }
-        Constant [ public int REDIS_SET ] { 2 }
-        Constant [ public int REDIS_LIST ] { 3 }
-        Constant [ public int REDIS_ZSET ] { 4 }
-        Constant [ public int REDIS_HASH ] { 5 }
-        Constant [ public int REDIS_STREAM ] { 6 }
-        Constant [ public int ATOMIC ] { 0 }
-        Constant [ public int MULTI ] { 1 }
-        Constant [ public int OPT_SERIALIZER ] { 1 }
-        Constant [ public int OPT_PREFIX ] { 2 }
-        Constant [ public int OPT_READ_TIMEOUT ] { 3 }
-        Constant [ public int OPT_TCP_KEEPALIVE ] { 6 }
-        Constant [ public int OPT_COMPRESSION ] { 7 }
-        Constant [ public int OPT_REPLY_LITERAL ] { 8 }
-        Constant [ public int OPT_COMPRESSION_LEVEL ] { 9 }
-        Constant [ public int OPT_NULL_MULTIBULK_AS_NULL ] { 10 }
-        Constant [ public int SERIALIZER_NONE ] { 0 }
-        Constant [ public int SERIALIZER_PHP ] { 1 }
-        Constant [ public int SERIALIZER_IGBINARY ] { 2 }
-        Constant [ public int SERIALIZER_MSGPACK ] { 3 }
-        Constant [ public int SERIALIZER_JSON ] { 4 }
-        Constant [ public int COMPRESSION_NONE ] { 0 }
-        Constant [ public int COMPRESSION_LZF ] { 1 }
-        Constant [ public int COMPRESSION_ZSTD ] { 2 }
-        Constant [ public int COMPRESSION_ZSTD_MIN ] { 1 }
-        Constant [ public int COMPRESSION_ZSTD_DEFAULT ] { 3 }
-        Constant [ public int COMPRESSION_ZSTD_MAX ] { 22 }
-        Constant [ public int COMPRESSION_LZ4 ] { 3 }
-        Constant [ public int OPT_SCAN ] { 4 }
-        Constant [ public int SCAN_RETRY ] { 1 }
-        Constant [ public int SCAN_NORETRY ] { 0 }
-        Constant [ public int SCAN_PREFIX ] { 2 }
-        Constant [ public int SCAN_NOPREFIX ] { 3 }
-        Constant [ public string AFTER ] { after }
-        Constant [ public string BEFORE ] { before }
+      - Constants [5] {
         Constant [ public int OPT_SLAVE_FAILOVER ] { 5 }
         Constant [ public int FAILOVER_NONE ] { 0 }
         Constant [ public int FAILOVER_ERROR ] { 1 }
         Constant [ public int FAILOVER_DISTRIBUTE ] { 2 }
         Constant [ public int FAILOVER_DISTRIBUTE_SLAVES ] { 3 }
-        Constant [ public int OPT_MAX_RETRIES ] { 11 }
-        Constant [ public int OPT_BACKOFF_ALGORITHM ] { 12 }
-        Constant [ public int BACKOFF_ALGORITHM_DEFAULT ] { 0 }
-        Constant [ public int BACKOFF_ALGORITHM_CONSTANT ] { 6 }
-        Constant [ public int BACKOFF_ALGORITHM_UNIFORM ] { 5 }
-        Constant [ public int BACKOFF_ALGORITHM_EXPONENTIAL ] { 4 }
-        Constant [ public int BACKOFF_ALGORITHM_FULL_JITTER ] { 2 }
-        Constant [ public int BACKOFF_ALGORITHM_EQUAL_JITTER ] { 3 }
-        Constant [ public int BACKOFF_ALGORITHM_DECORRELATED_JITTER ] { 1 }
-        Constant [ public int OPT_BACKOFF_BASE ] { 13 }
-        Constant [ public int OPT_BACKOFF_CAP ] { 14 }
       }
 
       - Static properties [0] {
@@ -2461,735 +2849,1035 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Properties [0] {
       }
 
-      - Methods [190] {
+      - Methods [222] {
         Method [ <internal:redis, ctor> public method __construct ] {
 
-          - Parameters [6] {
-            Parameter #0 [ <required> $name ]
-            Parameter #1 [ <optional> array $seeds = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
-            Parameter #3 [ <optional> $read_timeout = <default> ]
-            Parameter #4 [ <optional> $persistent = <default> ]
-            Parameter #5 [ <optional> $auth = <default> ]
+          - Parameters [7] {
+            Parameter #0 [ <required> ?string $name ]
+            Parameter #1 [ <optional> array $seeds = NULL ]
+            Parameter #2 [ <optional> int|float $timeout = 0 ]
+            Parameter #3 [ <optional> int|float $read_timeout = 0 ]
+            Parameter #4 [ <optional> bool $persistent = false ]
+            Parameter #5 [ <optional> mixed $auth = NULL ]
+            Parameter #6 [ <optional> array $context = NULL ]
           }
         }
 
-        Method [ <internal:redis> public method _masters ] {
+        Method [ <internal:redis> public method _compress ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _prefix ] {
+        Method [ <internal:redis> public method _uncompress ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _redir ] {
+        Method [ <internal:redis> public method _serialize ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> mixed $value ]
           }
+          - Return [ string|bool ]
         }
 
-        Method [ <internal:redis> public method _serialize ] {
+        Method [ <internal:redis> public method _unserialize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ mixed ]
         }
 
-        Method [ <internal:redis> public method _unserialize ] {
+        Method [ <internal:redis> public method _pack ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> mixed $value ]
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method _compress ] {
+        Method [ <internal:redis> public method _unpack ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $value ]
           }
+          - Return [ mixed ]
         }
 
-        Method [ <internal:redis> public method _uncompress ] {
+        Method [ <internal:redis> public method _prefix ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ string|bool ]
         }
 
-        Method [ <internal:redis> public method _pack ] {
+        Method [ <internal:redis> public method _masters ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ array ]
         }
 
-        Method [ <internal:redis> public method _unpack ] {
+        Method [ <internal:redis> public method _redir ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ ?string ]
         }
 
         Method [ <internal:redis> public method acl ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <required> $subcmd ]
-            Parameter #2 [ <optional> ...$args ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $subcmd ]
+            Parameter #2 [ <optional> string ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method append ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method bgrewriteaof ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method bgsave ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method bitcount ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $start = 0 ]
+            Parameter #2 [ <optional> int $end = -1 ]
+            Parameter #3 [ <optional> bool $bybit = false ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method bitop ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $operation ]
-            Parameter #1 [ <required> $ret_key ]
-            Parameter #2 [ <required> $key ]
-            Parameter #3 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <required> string $deskey ]
+            Parameter #2 [ <required> string $srckey ]
+            Parameter #3 [ <optional> string ...$otherkeys ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method bitpos ] {
 
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $bit ]
-            Parameter #2 [ <optional> $start = <default> ]
-            Parameter #3 [ <optional> $end = <default> ]
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> bool $bit ]
+            Parameter #2 [ <optional> int $start = 0 ]
+            Parameter #3 [ <optional> int $end = -1 ]
+            Parameter #4 [ <optional> bool $bybit = false ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method blpop ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int|float $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ RedisCluster|array|false|null ]
         }
 
         Method [ <internal:redis> public method brpop ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int|float $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ RedisCluster|array|false|null ]
         }
 
         Method [ <internal:redis> public method brpoplpush ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
-            Parameter #2 [ <required> $timeout ]
+            Parameter #0 [ <required> string $srckey ]
+            Parameter #1 [ <required> string $deskey ]
+            Parameter #2 [ <required> int $timeout ]
           }
+          - Return [ mixed ]
         }
 
-        Method [ <internal:redis> public method clearlasterror ] {
+        Method [ <internal:redis> public method lmove ] {
 
-          - Parameters [0] {
+          - Parameters [4] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> string $wherefrom ]
+            Parameter #3 [ <required> string $whereto ]
           }
+          - Return [ Redis|string|false ]
+        }
+
+        Method [ <internal:redis> public method blmove ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> string $wherefrom ]
+            Parameter #3 [ <required> string $whereto ]
+            Parameter #4 [ <required> float $timeout ]
+          }
+          - Return [ Redis|string|false ]
         }
 
         Method [ <internal:redis> public method bzpopmax ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:redis> public method bzpopmin ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout_or_key ]
-            Parameter #2 [ <optional> ...$extra_args ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <required> string|int $timeout_or_key ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
+          }
+          - Return [ array ]
+        }
+
+        Method [ <internal:redis> public method bzmpop ] {
+
+          - Parameters [4] {
+            Parameter #0 [ <required> float $timeout ]
+            Parameter #1 [ <required> array $keys ]
+            Parameter #2 [ <required> string $from ]
+            Parameter #3 [ <optional> int $count = 1 ]
+          }
+          - Return [ RedisCluster|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method zmpop ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <required> string $from ]
+            Parameter #2 [ <optional> int $count = 1 ]
+          }
+          - Return [ RedisCluster|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method blmpop ] {
+
+          - Parameters [4] {
+            Parameter #0 [ <required> float $timeout ]
+            Parameter #1 [ <required> array $keys ]
+            Parameter #2 [ <required> string $from ]
+            Parameter #3 [ <optional> int $count = 1 ]
+          }
+          - Return [ RedisCluster|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method lmpop ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <required> string $from ]
+            Parameter #2 [ <optional> int $count = 1 ]
+          }
+          - Return [ RedisCluster|array|false|null ]
+        }
+
+        Method [ <internal:redis> public method clearlasterror ] {
+
+          - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method client ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $subcommand ]
+            Parameter #2 [ <optional> ?string $arg = NULL ]
           }
+          - Return [ array|string|bool ]
         }
 
         Method [ <internal:redis> public method close ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method cluster ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $command ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method command ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> ...$args ]
+            Parameter #0 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method config ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $subcommand ]
+            Parameter #2 [ <optional> mixed ...$extra_args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method dbsize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+          }
+          - Return [ RedisCluster|int ]
+        }
+
+        Method [ <internal:redis> public method copy ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <optional> array $options = null ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method decr ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $by = 1 ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method decrby ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $value ]
+          }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method decrbyfloat ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $value ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:redis> public method del ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method discard ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method dump ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|string|false ]
         }
 
         Method [ <internal:redis> public method echo ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $msg ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $msg ]
           }
+          - Return [ RedisCluster|string|false ]
         }
 
         Method [ <internal:redis> public method eval ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $script ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
+            Parameter #0 [ <required> string $script ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
+          }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method eval_ro ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $script ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method evalsha ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $script_sha ]
-            Parameter #1 [ <optional> $args = <default> ]
-            Parameter #2 [ <optional> $num_keys = <default> ]
+            Parameter #0 [ <required> string $script_sha ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
           }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method evalsha_ro ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $script_sha ]
+            Parameter #1 [ <optional> array $args = [] ]
+            Parameter #2 [ <optional> int $num_keys = 0 ]
+          }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method exec ] {
 
           - Parameters [0] {
           }
+          - Return [ array|false ]
         }
 
         Method [ <internal:redis> public method exists ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> mixed $key ]
+            Parameter #1 [ <optional> mixed ...$other_keys ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
-        Method [ <internal:redis> public method expire ] {
+        Method [ <internal:redis> public method touch ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timeout ]
+            Parameter #0 [ <required> mixed $key ]
+            Parameter #1 [ <optional> mixed ...$other_keys ]
           }
+          - Return [ RedisCluster|int|bool ]
+        }
+
+        Method [ <internal:redis> public method expire ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
+          }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method expireat ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timestamp ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
+          }
+          - Return [ RedisCluster|bool ]
+        }
+
+        Method [ <internal:redis> public method expiretime ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $key ]
+          }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method pexpiretime ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method flushall ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $async = <default> ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> bool $async = false ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method flushdb ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $async = <default> ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> bool $async = false ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method geoadd ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lat ]
-            Parameter #3 [ <required> $member ]
-            Parameter #4 [ <optional> ...$other_triples ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> string $member ]
+            Parameter #4 [ <optional> mixed ...$other_triples_and_options ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method geodist ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $src ]
-            Parameter #2 [ <required> $dst ]
-            Parameter #3 [ <optional> $unit = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $src ]
+            Parameter #2 [ <required> string $dest ]
+            Parameter #3 [ <optional> ?string $unit = null ]
           }
+          - Return [ RedisCluster|float|false ]
         }
 
         Method [ <internal:redis> public method geohash ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method geopos ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method georadius ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lan ]
-            Parameter #3 [ <required> $radius ]
-            Parameter #4 [ <required> $unit ]
-            Parameter #5 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> float $radius ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadius_ro ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $lng ]
-            Parameter #2 [ <required> $lan ]
-            Parameter #3 [ <required> $radius ]
-            Parameter #4 [ <required> $unit ]
-            Parameter #5 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $lng ]
+            Parameter #2 [ <required> float $lat ]
+            Parameter #3 [ <required> float $radius ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadiusbymember ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $radius ]
-            Parameter #3 [ <required> $unit ]
-            Parameter #4 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> float $radius ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method georadiusbymember_ro ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $radius ]
-            Parameter #3 [ <required> $unit ]
-            Parameter #4 [ <optional> array $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> float $radius ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
           }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method geosearch ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array|string $position ]
+            Parameter #2 [ <required> array|int|float $shape ]
+            Parameter #3 [ <required> string $unit ]
+            Parameter #4 [ <optional> array $options = [] ]
+          }
+          - Return [ RedisCluster|array ]
+        }
+
+        Method [ <internal:redis> public method geosearchstore ] {
+
+          - Parameters [6] {
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $src ]
+            Parameter #2 [ <required> array|string $position ]
+            Parameter #3 [ <required> array|int|float $shape ]
+            Parameter #4 [ <required> string $unit ]
+            Parameter #5 [ <optional> array $options = [] ]
+          }
+          - Return [ RedisCluster|array|int|false ]
         }
 
         Method [ <internal:redis> public method get ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method getbit ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method getlasterror ] {
 
           - Parameters [0] {
           }
+          - Return [ ?string ]
         }
 
         Method [ <internal:redis> public method getmode ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:redis> public method getoption ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $option ]
+            Parameter #0 [ <required> int $option ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method getrange ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
+          }
+          - Return [ RedisCluster|string|false ]
+        }
+
+        Method [ <internal:redis> public method lcs ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key1 ]
+            Parameter #1 [ <required> string $key2 ]
+            Parameter #2 [ <optional> ?array $options = NULL ]
+          }
+          - Return [ RedisCluster|array|string|int|false ]
+        }
+
+        Method [ <internal:redis> public method getset ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+          }
+          - Return [ RedisCluster|string|bool ]
+        }
+
+        Method [ <internal:redis> public method gettransferredbytes ] {
+
+          - Parameters [0] {
           }
+          - Return [ array|false ]
         }
 
-        Method [ <internal:redis> public method getset ] {
+        Method [ <internal:redis> public method cleartransferredbytes ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ void ]
         }
 
         Method [ <internal:redis> public method hdel ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method hexists ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method hget ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method hgetall ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method hincrby ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> int $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method hincrbyfloat ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> float $value ]
           }
+          - Return [ RedisCluster|float|false ]
         }
 
         Method [ <internal:redis> public method hkeys ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method hlen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method hmget ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
             Parameter #1 [ <required> array $keys ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method hmset ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $pairs ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $key_values ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method hscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
+          }
+          - Return [ array|bool ]
+        }
+
+        Method [ <internal:redis> public method hrandfield ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> array $options = null ]
           }
+          - Return [ RedisCluster|array|string ]
         }
 
         Method [ <internal:redis> public method hset ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method hsetnx ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method hstrlen ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $field ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method hvals ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method incr ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $by = 1 ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method incrby ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method incrbyfloat ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $value ]
           }
+          - Return [ RedisCluster|float|false ]
         }
 
         Method [ <internal:redis> public method info ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $option = <default> ]
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> string ...$sections ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method keys ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pattern ]
+            Parameter #0 [ <required> string $pattern ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method lastsave ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method lget ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
           }
+          - Return [ RedisCluster|string|bool ]
         }
 
         Method [ <internal:redis> public method lindex ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method linsert ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $position ]
-            Parameter #2 [ <required> $pivot ]
-            Parameter #3 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $pos ]
+            Parameter #2 [ <required> mixed $pivot ]
+            Parameter #3 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method llen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method lpop ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
+          }
+          - Return [ RedisCluster|array|string|bool ]
+        }
+
+        Method [ <internal:redis> public method lpos ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> array $options = null ]
           }
+          - Return [ Redis|array|int|bool|null ]
         }
 
         Method [ <internal:redis> public method lpush ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed ...$other_values ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method lpushx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method lrange ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method lrem ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> int $count = 0 ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method lset ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $index ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $index ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method ltrim ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $stop ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $start ]
+            Parameter #2 [ <required> int $end ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method mget ] {
@@ -3197,847 +3885,1078 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
           - Parameters [1] {
             Parameter #0 [ <required> array $keys ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method mset ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> array $pairs ]
+            Parameter #0 [ <required> array $key_values ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method msetnx ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> array $pairs ]
+            Parameter #0 [ <required> array $key_values ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method multi ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <optional> int $value = Redis::MULTI ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method object ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $field ]
-            Parameter #1 [ <required> $key ]
+            Parameter #0 [ <required> string $subcommand ]
+            Parameter #1 [ <required> string $key ]
           }
+          - Return [ RedisCluster|string|int|false ]
         }
 
         Method [ <internal:redis> public method persist ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method pexpire ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method pexpireat ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $timestamp ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timestamp ]
+            Parameter #2 [ <optional> ?string $mode = NULL ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method pfadd ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
             Parameter #1 [ <required> array $elements ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method pfcount ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method pfmerge ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $dstkey ]
+            Parameter #0 [ <required> string $key ]
             Parameter #1 [ <required> array $keys ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method ping ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> ?string $message = NULL ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method psetex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $expire ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <required> string $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method psubscribe ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> array $patterns ]
-            Parameter #1 [ <required> $callback ]
+            Parameter #1 [ <required> callable $callback ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:redis> public method pttl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method publish ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $channel ]
-            Parameter #1 [ <required> $message ]
+            Parameter #0 [ <required> string $channel ]
+            Parameter #1 [ <required> string $message ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method pubsub ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> string ...$values ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method punsubscribe ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $pattern ]
-            Parameter #1 [ <optional> ...$other_patterns ]
+            Parameter #0 [ <required> string $pattern ]
+            Parameter #1 [ <optional> string ...$other_patterns ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method randomkey ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|string|bool ]
         }
 
         Method [ <internal:redis> public method rawcommand ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $cmd ]
-            Parameter #1 [ <optional> ...$args ]
+          - Parameters [3] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <required> string $command ]
+            Parameter #2 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method rename ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $newkey ]
+            Parameter #0 [ <required> string $key_src ]
+            Parameter #1 [ <required> string $key_dst ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method renamenx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $newkey ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $newkey ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method restore ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $ttl ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <required> $value ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $timeout ]
+            Parameter #2 [ <required> string $value ]
+            Parameter #3 [ <optional> ?array $options = NULL ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method role ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method rpop ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ RedisCluster|array|string|bool ]
         }
 
         Method [ <internal:redis> public method rpoplpush ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
           }
+          - Return [ RedisCluster|string|bool ]
         }
 
         Method [ <internal:redis> public method rpush ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> mixed ...$elements ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method rpushx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method sadd ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed ...$other_values ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method saddarray ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> array $options ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $values ]
           }
+          - Return [ RedisCluster|int|bool ]
         }
 
         Method [ <internal:redis> public method save ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key_or_address ]
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method scan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> &$i_iterator ]
-            Parameter #1 [ <required> $str_node ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> ?int &$iterator ]
+            Parameter #1 [ <required> array|string $key_or_address ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method scard ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method script ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> mixed ...$args ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method sdiff ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method sdiffstore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $key ]
+            Parameter #2 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method set ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <optional> $opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed $options = NULL ]
           }
+          - Return [ RedisCluster|string|bool ]
         }
 
         Method [ <internal:redis> public method setbit ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $offset ]
+            Parameter #2 [ <required> bool $onoff ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method setex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $expire ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $expire ]
+            Parameter #2 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method setnx ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method setoption ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $option ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> int $option ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method setrange ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $offset ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $offset ]
+            Parameter #2 [ <required> string $value ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method sinter ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
+          }
+          - Return [ RedisCluster|array|false ]
+        }
+
+        Method [ <internal:redis> public method sintercard ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> int $limit = -1 ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method sinterstore ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method sismember ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
-        Method [ <internal:redis> public method slowlog ] {
+        Method [ <internal:redis> public method smismember ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key_or_address ]
-            Parameter #1 [ <optional> $arg = <default> ]
-            Parameter #2 [ <optional> ...$other_args ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $member ]
+            Parameter #2 [ <optional> string ...$other_members ]
           }
+          - Return [ RedisCluster|array|false ]
+        }
+
+        Method [ <internal:redis> public method slowlog ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array|string $key_or_address ]
+            Parameter #1 [ <optional> mixed ...$args ]
+          }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method smembers ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method smove ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $src ]
-            Parameter #1 [ <required> $dst ]
-            Parameter #2 [ <required> $value ]
+            Parameter #0 [ <required> string $src ]
+            Parameter #1 [ <required> string $dst ]
+            Parameter #2 [ <required> string $member ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method sort ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?array $options = NULL ]
+          }
+          - Return [ RedisCluster|array|string|int|bool ]
+        }
+
+        Method [ <internal:redis> public method sort_ro ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> ?array $options = NULL ]
           }
+          - Return [ RedisCluster|array|string|int|bool ]
         }
 
         Method [ <internal:redis> public method spop ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ RedisCluster|array|string|false ]
         }
 
         Method [ <internal:redis> public method srandmember ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> $count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $count = 0 ]
           }
+          - Return [ RedisCluster|array|string|false ]
         }
 
         Method [ <internal:redis> public method srem ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $value ]
+            Parameter #2 [ <optional> mixed ...$other_values ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method sscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ array|false ]
         }
 
         Method [ <internal:redis> public method strlen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method subscribe ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> array $channels ]
-            Parameter #1 [ <required> $callback ]
+            Parameter #1 [ <required> callable $cb ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:redis> public method sunion ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method sunionstore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $dst ]
-            Parameter #1 [ <required> $key ]
-            Parameter #2 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> string $key ]
+            Parameter #2 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method time ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> array|string $key_or_address ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method ttl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method type ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method unsubscribe ] {
 
-          - Parameters [2] {
-            Parameter #0 [ <required> $channel ]
-            Parameter #1 [ <optional> ...$other_channels ]
+          - Parameters [1] {
+            Parameter #0 [ <required> array $channels ]
           }
+          - Return [ array|bool ]
         }
 
         Method [ <internal:redis> public method unlink ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> array|string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method unwatch ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:redis> public method watch ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <optional> ...$other_keys ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> string ...$other_keys ]
           }
+          - Return [ RedisCluster|bool ]
         }
 
         Method [ <internal:redis> public method xack ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <required> array $arr_ids ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> array $ids ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method xadd ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_id ]
-            Parameter #2 [ <required> array $arr_fields ]
-            Parameter #3 [ <optional> $i_maxlen = <default> ]
-            Parameter #4 [ <optional> $boo_approximate = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $id ]
+            Parameter #2 [ <required> array $values ]
+            Parameter #3 [ <optional> int $maxlen = 0 ]
+            Parameter #4 [ <optional> bool $approx = false ]
           }
+          - Return [ RedisCluster|string|false ]
         }
 
         Method [ <internal:redis> public method xclaim ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <required> $str_consumer ]
-            Parameter #3 [ <required> $i_min_idle ]
-            Parameter #4 [ <required> array $arr_ids ]
-            Parameter #5 [ <optional> array $arr_opts = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> string $consumer ]
+            Parameter #3 [ <required> int $min_iddle ]
+            Parameter #4 [ <required> array $ids ]
+            Parameter #5 [ <required> array $options ]
           }
+          - Return [ RedisCluster|array|string|false ]
         }
 
         Method [ <internal:redis> public method xdel ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> array $arr_ids ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array $ids ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method xgroup ] {
 
-          - Parameters [5] {
-            Parameter #0 [ <required> $str_operation ]
-            Parameter #1 [ <optional> $str_key = <default> ]
-            Parameter #2 [ <optional> $str_arg1 = <default> ]
-            Parameter #3 [ <optional> $str_arg2 = <default> ]
-            Parameter #4 [ <optional> $str_arg3 = <default> ]
+          - Parameters [6] {
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> string $key = null ]
+            Parameter #2 [ <optional> string $group = null ]
+            Parameter #3 [ <optional> string $id_or_consumer = null ]
+            Parameter #4 [ <optional> bool $mkstream = false ]
+            Parameter #5 [ <optional> int $entries_read = -2 ]
+          }
+          - Return [ mixed ]
+        }
+
+        Method [ <internal:redis> public method xautoclaim ] {
+
+          - Parameters [7] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <required> string $consumer ]
+            Parameter #3 [ <required> int $min_idle ]
+            Parameter #4 [ <required> string $start ]
+            Parameter #5 [ <optional> int $count = -1 ]
+            Parameter #6 [ <optional> bool $justid = false ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method xinfo ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $str_cmd ]
-            Parameter #1 [ <optional> $str_key = <default> ]
-            Parameter #2 [ <optional> $str_group = <default> ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $operation ]
+            Parameter #1 [ <optional> ?string $arg1 = null ]
+            Parameter #2 [ <optional> ?string $arg2 = null ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ mixed ]
         }
 
         Method [ <internal:redis> public method xlen ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method xpending ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_group ]
-            Parameter #2 [ <optional> $str_start = <default> ]
-            Parameter #3 [ <optional> $str_end = <default> ]
-            Parameter #4 [ <optional> $i_count = <default> ]
-            Parameter #5 [ <optional> $str_consumer = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $group ]
+            Parameter #2 [ <optional> ?string $start = null ]
+            Parameter #3 [ <optional> ?string $end = null ]
+            Parameter #4 [ <optional> int $count = -1 ]
+            Parameter #5 [ <optional> ?string $consumer = null ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method xrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_start ]
-            Parameter #2 [ <required> $str_end ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method xread ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> array $arr_streams ]
-            Parameter #1 [ <optional> $i_count = <default> ]
-            Parameter #2 [ <optional> $i_block = <default> ]
+            Parameter #0 [ <required> array $streams ]
+            Parameter #1 [ <optional> int $count = -1 ]
+            Parameter #2 [ <optional> int $block = -1 ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method xreadgroup ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $str_group ]
-            Parameter #1 [ <required> $str_consumer ]
-            Parameter #2 [ <required> array $arr_streams ]
-            Parameter #3 [ <optional> $i_count = <default> ]
-            Parameter #4 [ <optional> $i_block = <default> ]
+            Parameter #0 [ <required> string $group ]
+            Parameter #1 [ <required> string $consumer ]
+            Parameter #2 [ <required> array $streams ]
+            Parameter #3 [ <optional> int $count = 1 ]
+            Parameter #4 [ <optional> int $block = 1 ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method xrevrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $str_start ]
-            Parameter #2 [ <required> $str_end ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
+            Parameter #3 [ <optional> int $count = -1 ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method xtrim ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> $i_maxlen ]
-            Parameter #2 [ <optional> $boo_approximate = <default> ]
+          - Parameters [5] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> int $maxlen ]
+            Parameter #2 [ <optional> bool $approx = false ]
+            Parameter #3 [ <optional> bool $minid = false ]
+            Parameter #4 [ <optional> int $limit = -1 ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zadd ] {
 
-          - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $score ]
-            Parameter #2 [ <required> $value ]
-            Parameter #3 [ <optional> ...$extra_args ]
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> array|float $score_or_options ]
+            Parameter #2 [ <optional> mixed ...$more_scores_and_mems ]
           }
+          - Return [ RedisCluster|int|float|false ]
         }
 
         Method [ <internal:redis> public method zcard ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zcount ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zincrby ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
-            Parameter #2 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> float $value ]
+            Parameter #2 [ <required> string $member ]
           }
+          - Return [ RedisCluster|float|false ]
         }
 
         Method [ <internal:redis> public method zinterstore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $dst ]
             Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
+            Parameter #2 [ <optional> ?array $weights = null ]
+            Parameter #3 [ <optional> ?string $aggregate = null ]
+          }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method zintercard ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> int $limit = -1 ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zlexcount ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zpopmax ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $value = null ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zpopmin ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> int $value = null ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> $scores = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $start ]
+            Parameter #2 [ <required> mixed $end ]
+            Parameter #3 [ <optional> array|bool|null $options = null ]
+          }
+          - Return [ RedisCluster|array|bool ]
+        }
+
+        Method [ <internal:redis> public method zrangestore ] {
+
+          - Parameters [5] {
+            Parameter #0 [ <required> string $dstkey ]
+            Parameter #1 [ <required> string $srckey ]
+            Parameter #2 [ <required> int $start ]
+            Parameter #3 [ <required> int $end ]
+            Parameter #4 [ <optional> array|bool|null $options = null ]
           }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method zrandmember ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <optional> array $options = null ]
+          }
+          - Return [ RedisCluster|array|string ]
         }
 
         Method [ <internal:redis> public method zrangebylex ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-            Parameter #3 [ <optional> $offset = <default> ]
-            Parameter #4 [ <optional> $limit = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+            Parameter #3 [ <optional> int $offset = -1 ]
+            Parameter #4 [ <optional> int $count = -1 ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method zrangebyscore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $start ]
+            Parameter #2 [ <required> string $end ]
+            Parameter #3 [ <optional> array $options = [] ]
           }
+          - Return [ RedisCluster|array|false ]
         }
 
         Method [ <internal:redis> public method zrank ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zrem ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
-            Parameter #2 [ <optional> ...$other_members ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $value ]
+            Parameter #2 [ <optional> string ...$other_values ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zremrangebylex ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zremrangebyrank ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zremrangebyscore ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zrevrange ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> $scores = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+            Parameter #3 [ <optional> array $options = null ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zrevrangebylex ] {
 
-          - Parameters [5] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $min ]
-            Parameter #2 [ <required> $max ]
-            Parameter #3 [ <optional> $offset = <default> ]
-            Parameter #4 [ <optional> $limit = <default> ]
+          - Parameters [4] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+            Parameter #3 [ <optional> array $options = null ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zrevrangebyscore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $start ]
-            Parameter #2 [ <required> $end ]
-            Parameter #3 [ <optional> array $options = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $min ]
+            Parameter #2 [ <required> string $max ]
+            Parameter #3 [ <optional> array $options = null ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zrevrank ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
           }
+          - Return [ RedisCluster|int|false ]
         }
 
         Method [ <internal:redis> public method zscan ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $str_key ]
-            Parameter #1 [ <required> &$i_iterator ]
-            Parameter #2 [ <optional> $str_pattern = <default> ]
-            Parameter #3 [ <optional> $i_count = <default> ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> ?int &$iterator ]
+            Parameter #2 [ <optional> ?string $pattern = null ]
+            Parameter #3 [ <optional> int $count = 0 ]
           }
+          - Return [ RedisCluster|array|bool ]
         }
 
         Method [ <internal:redis> public method zscore ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $member ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
+          }
+          - Return [ RedisCluster|float|false ]
+        }
+
+        Method [ <internal:redis> public method zmscore ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> mixed $member ]
+            Parameter #2 [ <optional> mixed ...$other_members ]
           }
+          - Return [ Redis|array|false ]
         }
 
         Method [ <internal:redis> public method zunionstore ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $dst ]
+            Parameter #1 [ <required> array $keys ]
+            Parameter #2 [ <optional> ?array $weights = NULL ]
+            Parameter #3 [ <optional> ?string $aggregate = NULL ]
+          }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method zinter ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> ?array $weights = null ]
+            Parameter #2 [ <optional> ?array $options = null ]
+          }
+          - Return [ RedisCluster|array|false ]
+        }
+
+        Method [ <internal:redis> public method zdiffstore ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> string $dst ]
             Parameter #1 [ <required> array $keys ]
-            Parameter #2 [ <optional> ?array $weights = <default> ]
-            Parameter #3 [ <optional> $aggregate = <default> ]
           }
+          - Return [ RedisCluster|int|false ]
+        }
+
+        Method [ <internal:redis> public method zunion ] {
+
+          - Parameters [3] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> ?array $weights = null ]
+            Parameter #2 [ <optional> ?array $options = null ]
+          }
+          - Return [ RedisCluster|array|false ]
+        }
+
+        Method [ <internal:redis> public method zdiff ] {
+
+          - Parameters [2] {
+            Parameter #0 [ <required> array $keys ]
+            Parameter #1 [ <optional> array $options = null ]
+          }
+          - Return [ RedisCluster|array|false ]
         }
       }
     }
 
-    Class [ <internal:redis> class RedisSentinel ] {
+    Class [ <internal:redis> class RedisClusterException extends RuntimeException implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -4048,92 +4967,88 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Static methods [0] {
       }
 
-      - Properties [0] {
+      - Properties [4] {
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected string $file = '' ]
+        Property [ protected int $line = 0 ]
       }
 
-      - Methods [11] {
-        Method [ <internal:redis, ctor> public method __construct ] {
-
-          - Parameters [6] {
-            Parameter #0 [ <required> $host ]
-            Parameter #1 [ <optional> $port = <default> ]
-            Parameter #2 [ <optional> $timeout = <default> ]
-            Parameter #3 [ <optional> $persistent = <default> ]
-            Parameter #4 [ <optional> $retry_interval = <default> ]
-            Parameter #5 [ <optional> $read_timeout = <default> ]
-          }
-        }
-
-        Method [ <internal:redis> public method ckquorum ] {
+      - Methods [10] {
+        Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [3] {
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
-        Method [ <internal:redis> public method failover ] {
+        Method [ <internal:Core, inherits Exception> public method __wakeup ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Tentative return [ void ]
         }
 
-        Method [ <internal:redis> public method flushconfig ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method getMasterAddrByName ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
         }
 
-        Method [ <internal:redis> public method master ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method masters ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
-        Method [ <internal:redis> public method ping ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
-        Method [ <internal:redis> public method reset ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ ?Throwable ]
         }
 
-        Method [ <internal:redis> public method sentinels ] {
+        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ string ]
         }
 
-        Method [ <internal:redis> public method slaves ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
 
-          - Parameters [1] {
-            Parameter #0 [ <required> $value ]
+          - Parameters [0] {
           }
+          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:redis> class RedisException extends Exception implements Throwable, Stringable ] {
+    Class [ <internal:redis> class RedisSentinel ] {
 
       - Constants [0] {
       }
@@ -4144,87 +5059,94 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Static methods [0] {
       }
 
-      - Properties [4] {
-        Property [ protected $message = '' ]
-        Property [ protected $code = 0 ]
-        Property [ protected $file = NULL ]
-        Property [ protected $line = NULL ]
+      - Properties [0] {
       }
 
-      - Methods [10] {
-        Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
+      - Methods [12] {
+        Method [ <internal:redis, ctor> public method __construct ] {
 
-          - Parameters [3] {
-            Parameter #0 [ <optional> string $message = "" ]
-            Parameter #1 [ <optional> int $code = 0 ]
-            Parameter #2 [ <optional> ?Throwable $previous = null ]
+          - Parameters [1] {
+            Parameter #0 [ <optional> array $options = null ]
           }
         }
 
-        Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+        Method [ <internal:redis> public method ckquorum ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
           }
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+        Method [ <internal:redis> public method failover ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
           }
-          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+        Method [ <internal:redis> public method flushconfig ] {
 
           - Parameters [0] {
           }
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+        Method [ <internal:redis> public method getMasterAddrByName ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
           }
-          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+        Method [ <internal:redis> public method master ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
           }
-          - Return [ int ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+        Method [ <internal:redis> public method masters ] {
 
           - Parameters [0] {
           }
-          - Return [ array ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+        Method [ <internal:redis> public method myid ] {
 
           - Parameters [0] {
           }
-          - Return [ ?Throwable ]
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+        Method [ <internal:redis> public method ping ] {
 
           - Parameters [0] {
           }
-          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+        Method [ <internal:redis> public method reset ] {
 
-          - Parameters [0] {
+          - Parameters [1] {
+            Parameter #0 [ <required> string $pattern ]
+          }
+        }
+
+        Method [ <internal:redis> public method sentinels ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
+          }
+        }
+
+        Method [ <internal:redis> public method slaves ] {
+
+          - Parameters [1] {
+            Parameter #0 [ <required> string $master ]
           }
-          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:redis> class RedisClusterException extends Exception implements Throwable, Stringable ] {
+    Class [ <internal:redis> class RedisException extends RuntimeException implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -4238,8 +5160,8 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
       - Properties [4] {
         Property [ protected $message = '' ]
         Property [ protected $code = 0 ]
-        Property [ protected $file = NULL ]
-        Property [ protected $line = NULL ]
+        Property [ protected string $file = '' ]
+        Property [ protected int $line = 0 ]
       }
 
       - Methods [10] {
@@ -4256,6 +5178,7 @@ Extension [ <persistent> extension #117 redis version 5.3.7 ] {
 
           - Parameters [0] {
           }
+          - Tentative return [ void ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
-- 
cgit