From b8c80a74f9245c0750593e5e2262644a426e80bc Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Thu, 9 Jul 2026 20:32:12 +0100
Subject: [PATCH 1/3] add auto-generated file to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 37a1d8b4..782905a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,5 @@ vendor/
 /generator/tests/rector/composer.lock
 .phpunit.result.cache
 .phpunit.cache
+.phpactor.json
 docs/

From c411d443abe0d938b606ed8addda8b85aa0b28e4 Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Thu, 9 Jul 2026 21:06:03 +0100
Subject: [PATCH 2/3] regenerate

---
 composer.json                               |    1 +
 generated/8.6/exec.php                      |  116 ++
 generated/8.6/functionsList.php             |   52 +-
 generated/8.6/image.php                     | 1613 +++++++++++++++++++
 generated/8.6/ldap.php                      |   36 +-
 generated/8.6/litespeed.php                 |   18 +
 generated/8.6/pcntl.php                     |   22 +
 generated/8.6/pgsql.php                     |  882 ++++++++++
 generated/8.6/rector-migrate.php            |   52 +-
 generated/8.6/sodium.php                    |  310 ++++
 generated/8.6/ssh2.php                      |  558 +++++++
 generated/8.6/stream.php                    |  490 ++++++
 generated/Exceptions/LitespeedException.php |   11 +
 generated/exec.php                          |    2 +-
 generated/image.php                         |    2 +-
 generated/litespeed.php                     |    5 +
 generated/pgsql.php                         |    2 +-
 generated/sodium.php                        |    2 +-
 generated/ssh2.php                          |    2 +-
 generated/stream.php                        |    2 +-
 20 files changed, 4088 insertions(+), 90 deletions(-)
 create mode 100644 generated/8.6/exec.php
 create mode 100644 generated/8.6/image.php
 create mode 100644 generated/8.6/litespeed.php
 create mode 100644 generated/8.6/pgsql.php
 create mode 100644 generated/8.6/sodium.php
 create mode 100644 generated/8.6/ssh2.php
 create mode 100644 generated/8.6/stream.php
 create mode 100644 generated/Exceptions/LitespeedException.php
 create mode 100644 generated/litespeed.php

diff --git a/composer.json b/composer.json
index 8cba071c..3b90b136 100644
--- a/composer.json
+++ b/composer.json
@@ -45,6 +45,7 @@
             "generated/json.php",
             "generated/ldap.php",
             "generated/libxml.php",
+            "generated/litespeed.php",
             "generated/lzf.php",
             "generated/mailparse.php",
             "generated/mbstring.php",
diff --git a/generated/8.6/exec.php b/generated/8.6/exec.php
new file mode 100644
index 00000000..313cb07c
--- /dev/null
+++ b/generated/8.6/exec.php
@@ -0,0 +1,116 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ExecException;
+
+/**
+ * @param string $command
+ * @param array|null $output
+ * @param int|null $result_code
+ * @return string
+ * @throws ExecException
+ *
+ */
+function exec(string $command, ?array &$output = null, ?int &$result_code = null): string
+{
+    error_clear_last();
+    $safeResult = \exec($command, $output, $result_code);
+    if ($safeResult === false) {
+        throw ExecException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $process
+ * @return int
+ *
+ */
+function proc_close($process): int
+{
+    error_clear_last();
+    $safeResult = \proc_close($process);
+    return $safeResult;
+}
+
+
+/**
+ * @param int $priority
+ * @throws ExecException
+ *
+ */
+function proc_nice(int $priority): void
+{
+    error_clear_last();
+    $safeResult = \proc_nice($priority);
+    if ($safeResult === false) {
+        throw ExecException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $command
+ * @param array $descriptor_spec
+ * @param null|resource[] $pipes
+ * @param null|string $cwd
+ * @param array|null $env_vars
+ * @param array|null $options
+ * @return resource
+ * @throws ExecException
+ *
+ */
+function proc_open(string $command, array $descriptor_spec, ?array &$pipes, ?string $cwd = null, ?array $env_vars = null, ?array $options = null)
+{
+    error_clear_last();
+    if ($options !== null) {
+        $safeResult = \proc_open($command, $descriptor_spec, $pipes, $cwd, $env_vars, $options);
+    } elseif ($env_vars !== null) {
+        $safeResult = \proc_open($command, $descriptor_spec, $pipes, $cwd, $env_vars);
+    } elseif ($cwd !== null) {
+        $safeResult = \proc_open($command, $descriptor_spec, $pipes, $cwd);
+    } else {
+        $safeResult = \proc_open($command, $descriptor_spec, $pipes);
+    }
+    if ($safeResult === false) {
+        throw ExecException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $command
+ * @return null|string
+ * @throws ExecException
+ *
+ */
+function shell_exec(string $command): ?string
+{
+    error_clear_last();
+    $safeResult = \shell_exec($command);
+    if ($safeResult === false) {
+        throw ExecException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $command
+ * @param int|null $result_code
+ * @return string
+ * @throws ExecException
+ *
+ */
+function system(string $command, ?int &$result_code = null): string
+{
+    error_clear_last();
+    $safeResult = \system($command, $result_code);
+    if ($safeResult === false) {
+        throw ExecException::createFromPhpError();
+    }
+    return $safeResult;
+}
diff --git a/generated/8.6/functionsList.php b/generated/8.6/functionsList.php
index b1e384df..9833f03a 100644
--- a/generated/8.6/functionsList.php
+++ b/generated/8.6/functionsList.php
@@ -307,23 +307,11 @@
     'imageaffine',
     'imageaffinematrixconcat',
     'imageaffinematrixget',
-    'imagealphablending',
-    'imageantialias',
-    'imagearc',
     'imageavif',
     'imagebmp',
-    'imagechar',
-    'imagecharup',
     'imagecolorat',
-    'imagecolordeallocate',
-    'imagecolormatch',
     'imagecolorset',
     'imageconvolution',
-    'imagecopy',
-    'imagecopymerge',
-    'imagecopymergegray',
-    'imagecopyresampled',
-    'imagecopyresized',
     'imagecreate',
     'imagecreatefromavif',
     'imagecreatefrombmp',
@@ -342,43 +330,21 @@
     'imagecreatetruecolor',
     'imagecrop',
     'imagecropauto',
-    'imagedashedline',
-    'imagedestroy',
-    'imageellipse',
-    'imagefill',
-    'imagefilledarc',
-    'imagefilledellipse',
-    'imagefilledrectangle',
-    'imagefilltoborder',
     'imagefilter',
-    'imageflip',
     'imageftbbox',
     'imagefttext',
-    'imagegammacorrect',
     'imagegd',
     'imagegd2',
     'imagegif',
     'imagegrabscreen',
     'imagegrabwindow',
     'imagejpeg',
-    'imagelayereffect',
-    'imageline',
     'imageloadfont',
     'imagepng',
-    'imagerectangle',
-    'imageresolution',
     'imagerotate',
-    'imagesavealpha',
     'imagescale',
-    'imagesetbrush',
-    'imagesetclip',
     'imagesetinterpolation',
-    'imagesetpixel',
     'imagesetstyle',
-    'imagesetthickness',
-    'imagesettile',
-    'imagestring',
-    'imagestringup',
     'imagetruecolortopalette',
     'imagettfbbox',
     'imagettftext',
@@ -450,11 +416,11 @@
     'ldap_compare',
     'ldap_control_paged_result',
     'ldap_control_paged_result_response',
-    'ldap_count_entries',
     'ldap_delete',
     'ldap_dn2ufn',
     'ldap_exop',
     'ldap_exop_passwd',
+    'ldap_exop_sync',
     'ldap_exop_whoami',
     'ldap_explode_dn',
     'ldap_first_attribute',
@@ -477,6 +443,7 @@
     'ldap_set_option',
     'ldap_unbind',
     'link',
+    'litespeed_finish_request',
     'lstat',
     'lzf_compress',
     'lzf_decompress',
@@ -676,6 +643,7 @@
     'pcntl_getcpuaffinity',
     'pcntl_getpriority',
     'pcntl_setcpuaffinity',
+    'pcntl_setns',
     'pcntl_setpriority',
     'pcntl_signal',
     'pcntl_signal_dispatch',
@@ -684,6 +652,7 @@
     'pcntl_sigwaitinfo',
     'pfsockopen',
     'pg_cancel_query',
+    'pg_change_password',
     'pg_connect',
     'pg_connection_reset',
     'pg_convert',
@@ -691,6 +660,8 @@
     'pg_copy_to',
     'pg_delete',
     'pg_end_copy',
+    'pg_escape_identifier',
+    'pg_escape_literal',
     'pg_execute',
     'pg_field_num',
     'pg_field_table',
@@ -720,6 +691,7 @@
     'pg_result_seek',
     'pg_select',
     'pg_set_chunked_rows_size',
+    'pg_set_error_verbosity',
     'pg_socket',
     'pg_trace',
     'pg_update',
@@ -755,7 +727,6 @@
     'preg_replace_callback',
     'preg_replace_callback_array',
     'preg_split',
-    'proc_close',
     'proc_nice',
     'proc_open',
     'pspell_add_to_personal',
@@ -961,16 +932,12 @@
     'sodium_crypto_aead_aegis256_decrypt',
     'sodium_crypto_aead_aes256gcm_decrypt',
     'sodium_crypto_aead_chacha20poly1305_decrypt',
-    'sodium_crypto_aead_chacha20poly1305_encrypt',
     'sodium_crypto_aead_chacha20poly1305_ietf_decrypt',
-    'sodium_crypto_aead_chacha20poly1305_ietf_encrypt',
     'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt',
-    'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt',
     'sodium_crypto_box_open',
     'sodium_crypto_box_seal_open',
     'sodium_crypto_secretbox_open',
     'sodium_crypto_sign_open',
-    'sodium_crypto_stream_xchacha20_xor_ic',
     'solr_get_version',
     'spl_autoload_register',
     'spl_autoload_unregister',
@@ -998,6 +965,7 @@
     'ssh2_auth_agent',
     'ssh2_auth_hostbased_file',
     'ssh2_auth_password',
+    'ssh2_auth_pubkey',
     'ssh2_auth_pubkey_file',
     'ssh2_connect',
     'ssh2_disconnect',
@@ -1012,9 +980,13 @@
     'ssh2_send_eof',
     'ssh2_sftp',
     'ssh2_sftp_chmod',
+    'ssh2_sftp_lstat',
     'ssh2_sftp_mkdir',
+    'ssh2_sftp_readlink',
+    'ssh2_sftp_realpath',
     'ssh2_sftp_rename',
     'ssh2_sftp_rmdir',
+    'ssh2_sftp_stat',
     'ssh2_sftp_symlink',
     'ssh2_sftp_unlink',
     'ssh2_shell',
diff --git a/generated/8.6/image.php b/generated/8.6/image.php
new file mode 100644
index 00000000..feb2b32c
--- /dev/null
+++ b/generated/8.6/image.php
@@ -0,0 +1,1613 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ImageException;
+
+/**
+ * @param string $filename
+ * @param array|null $image_info
+ * @return array{0: 0|positive-int, 1: 0|positive-int, 2: int, 3: string, mime: string, channels: int, bits: int}|null
+ * @throws ImageException
+ *
+ */
+function getimagesize(string $filename, ?array &$image_info = null): ?array
+{
+    error_clear_last();
+    $safeResult = \getimagesize($filename, $image_info);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $image_type
+ * @param bool $include_dot
+ * @return string
+ * @throws ImageException
+ *
+ */
+function image_type_to_extension(int $image_type, bool $include_dot = true): string
+{
+    error_clear_last();
+    $safeResult = \image_type_to_extension($image_type, $include_dot);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param array $affine
+ * @param array|null $clip
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imageaffine(\GdImage $image, array $affine, ?array $clip = null): \GdImage
+{
+    error_clear_last();
+    if ($clip !== null) {
+        $safeResult = \imageaffine($image, $affine, $clip);
+    } else {
+        $safeResult = \imageaffine($image, $affine);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param array $matrix1
+ * @param array $matrix2
+ * @return array{0:float,1:float,2:float,3:float,4:float,5:float}
+ * @throws ImageException
+ *
+ */
+function imageaffinematrixconcat(array $matrix1, array $matrix2): array
+{
+    error_clear_last();
+    $safeResult = \imageaffinematrixconcat($matrix1, $matrix2);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $type
+ * @param array|float $options
+ * @return array{0:float,1:float,2:float,3:float,4:float,5:float}
+ * @throws ImageException
+ *
+ */
+function imageaffinematrixget(int $type, $options): array
+{
+    error_clear_last();
+    $safeResult = \imageaffinematrixget($type, $options);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param bool $enable
+ * @return bool
+ *
+ */
+function imagealphablending(\GdImage $image, bool $enable): bool
+{
+    error_clear_last();
+    $safeResult = \imagealphablending($image, $enable);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param bool $enable
+ * @return bool
+ *
+ */
+function imageantialias(\GdImage $image, bool $enable): bool
+{
+    error_clear_last();
+    $safeResult = \imageantialias($image, $enable);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $center_x
+ * @param int $center_y
+ * @param int $width
+ * @param int $height
+ * @param int $start_angle
+ * @param int $end_angle
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagearc(\GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagearc($image, $center_x, $center_y, $width, $height, $start_angle, $end_angle, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int $quality
+ * @param int $speed
+ * @throws ImageException
+ *
+ */
+function imageavif(\GdImage $image, $file = null, int $quality = -1, int $speed = -1): void
+{
+    error_clear_last();
+    if ($speed !== -1) {
+        $safeResult = \imageavif($image, $file, $quality, $speed);
+    } elseif ($quality !== -1) {
+        $safeResult = \imageavif($image, $file, $quality);
+    } elseif ($file !== null) {
+        $safeResult = \imageavif($image, $file);
+    } else {
+        $safeResult = \imageavif($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param bool $compressed
+ * @throws ImageException
+ *
+ */
+function imagebmp(\GdImage $image, $file = null, bool $compressed = true): void
+{
+    error_clear_last();
+    if ($compressed !== true) {
+        $safeResult = \imagebmp($image, $file, $compressed);
+    } elseif ($file !== null) {
+        $safeResult = \imagebmp($image, $file);
+    } else {
+        $safeResult = \imagebmp($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $font
+ * @param int $x
+ * @param int $y
+ * @param string $char
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagechar(\GdImage $image, int $font, int $x, int $y, string $char, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagechar($image, $font, $x, $y, $char, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $font
+ * @param int $x
+ * @param int $y
+ * @param string $char
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagecharup(\GdImage $image, int $font, int $x, int $y, string $char, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagecharup($image, $font, $x, $y, $char, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x
+ * @param int $y
+ * @return int
+ * @throws ImageException
+ *
+ */
+function imagecolorat(\GdImage $image, int $x, int $y): int
+{
+    error_clear_last();
+    $safeResult = \imagecolorat($image, $x, $y);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagecolordeallocate(\GdImage $image, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagecolordeallocate($image, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image1
+ * @param \GdImage $image2
+ * @return bool
+ *
+ */
+function imagecolormatch(\GdImage $image1, \GdImage $image2): bool
+{
+    error_clear_last();
+    $safeResult = \imagecolormatch($image1, $image2);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $color
+ * @param int $red
+ * @param int $green
+ * @param int $blue
+ * @param int $alpha
+ * @throws ImageException
+ *
+ */
+function imagecolorset(\GdImage $image, int $color, int $red, int $green, int $blue, int $alpha = 0): void
+{
+    error_clear_last();
+    $safeResult = \imagecolorset($image, $color, $red, $green, $blue, $alpha);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $color
+ * @return array{red: int, green: int, blue: int, alpha: int}
+ *
+ */
+function imagecolorsforindex(\GdImage $image, int $color): array
+{
+    error_clear_last();
+    $safeResult = \imagecolorsforindex($image, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param array $matrix
+ * @param float $divisor
+ * @param float $offset
+ * @throws ImageException
+ *
+ */
+function imageconvolution(\GdImage $image, array $matrix, float $divisor, float $offset): void
+{
+    error_clear_last();
+    $safeResult = \imageconvolution($image, $matrix, $divisor, $offset);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $dst_image
+ * @param \GdImage $src_image
+ * @param int $dst_x
+ * @param int $dst_y
+ * @param int $src_x
+ * @param int $src_y
+ * @param int $src_width
+ * @param int $src_height
+ * @return bool
+ *
+ */
+function imagecopy(\GdImage $dst_image, \GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height): bool
+{
+    error_clear_last();
+    $safeResult = \imagecopy($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $src_width, $src_height);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $dst_image
+ * @param \GdImage $src_image
+ * @param int $dst_x
+ * @param int $dst_y
+ * @param int $src_x
+ * @param int $src_y
+ * @param int $src_width
+ * @param int $src_height
+ * @param int $pct
+ * @return bool
+ *
+ */
+function imagecopymerge(\GdImage $dst_image, \GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): bool
+{
+    error_clear_last();
+    $safeResult = \imagecopymerge($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $src_width, $src_height, $pct);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $dst_image
+ * @param \GdImage $src_image
+ * @param int $dst_x
+ * @param int $dst_y
+ * @param int $src_x
+ * @param int $src_y
+ * @param int $src_width
+ * @param int $src_height
+ * @param int $pct
+ * @return bool
+ *
+ */
+function imagecopymergegray(\GdImage $dst_image, \GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): bool
+{
+    error_clear_last();
+    $safeResult = \imagecopymergegray($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $src_width, $src_height, $pct);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $dst_image
+ * @param \GdImage $src_image
+ * @param int $dst_x
+ * @param int $dst_y
+ * @param int $src_x
+ * @param int $src_y
+ * @param int $dst_width
+ * @param int $dst_height
+ * @param int $src_width
+ * @param int $src_height
+ * @return bool
+ *
+ */
+function imagecopyresampled(\GdImage $dst_image, \GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): bool
+{
+    error_clear_last();
+    $safeResult = \imagecopyresampled($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_width, $dst_height, $src_width, $src_height);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $dst_image
+ * @param \GdImage $src_image
+ * @param int $dst_x
+ * @param int $dst_y
+ * @param int $src_x
+ * @param int $src_y
+ * @param int $dst_width
+ * @param int $dst_height
+ * @param int $src_width
+ * @param int $src_height
+ * @return bool
+ *
+ */
+function imagecopyresized(\GdImage $dst_image, \GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): bool
+{
+    error_clear_last();
+    $safeResult = \imagecopyresized($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_width, $dst_height, $src_width, $src_height);
+    return $safeResult;
+}
+
+
+/**
+ * @param int $width
+ * @param int $height
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreate(int $width, int $height): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreate($width, $height);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromavif(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromavif($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefrombmp(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefrombmp($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromgd(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromgd($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromgd2(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromgd2($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @param int $x
+ * @param int $y
+ * @param int $width
+ * @param int $height
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromgd2part(string $filename, int $x, int $y, int $width, int $height): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromgd2part($filename, $x, $y, $width, $height);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromgif(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromgif($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromjpeg(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromjpeg($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefrompng(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefrompng($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromstring(string $data): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromstring($data);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromtga(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromtga($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromwbmp(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromwbmp($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromwebp(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromwebp($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromxbm(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromxbm($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatefromxpm(string $filename): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatefromxpm($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $width
+ * @param int $height
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecreatetruecolor(int $width, int $height): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecreatetruecolor($width, $height);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param array $rectangle
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecrop(\GdImage $image, array $rectangle): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecrop($image, $rectangle);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $mode
+ * @param float $threshold
+ * @param int $color
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagecropauto(\GdImage $image, int $mode = IMG_CROP_DEFAULT, float $threshold = 0.5, int $color = -1): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagecropauto($image, $mode, $threshold, $color);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x1
+ * @param int $y1
+ * @param int $x2
+ * @param int $y2
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagedashedline(\GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagedashedline($image, $x1, $y1, $x2, $y2, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @return bool
+ *
+ */
+function imagedestroy(\GdImage $image): bool
+{
+    error_clear_last();
+    $safeResult = \imagedestroy($image);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $center_x
+ * @param int $center_y
+ * @param int $width
+ * @param int $height
+ * @param int $color
+ * @return bool
+ *
+ */
+function imageellipse(\GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imageellipse($image, $center_x, $center_y, $width, $height, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x
+ * @param int $y
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagefill(\GdImage $image, int $x, int $y, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagefill($image, $x, $y, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $center_x
+ * @param int $center_y
+ * @param int $width
+ * @param int $height
+ * @param int $start_angle
+ * @param int $end_angle
+ * @param int $color
+ * @param int $style
+ * @return bool
+ *
+ */
+function imagefilledarc(\GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color, int $style): bool
+{
+    error_clear_last();
+    $safeResult = \imagefilledarc($image, $center_x, $center_y, $width, $height, $start_angle, $end_angle, $color, $style);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $center_x
+ * @param int $center_y
+ * @param int $width
+ * @param int $height
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagefilledellipse(\GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagefilledellipse($image, $center_x, $center_y, $width, $height, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x1
+ * @param int $y1
+ * @param int $x2
+ * @param int $y2
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagefilledrectangle(\GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagefilledrectangle($image, $x1, $y1, $x2, $y2, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x
+ * @param int $y
+ * @param int $border_color
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagefilltoborder(\GdImage $image, int $x, int $y, int $border_color, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagefilltoborder($image, $x, $y, $border_color, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $filter
+ * @param int $args
+ * @throws ImageException
+ *
+ */
+function imagefilter(\GdImage $image, int $filter, int ...$args): void
+{
+    error_clear_last();
+    if ($args !== []) {
+        $safeResult = \imagefilter($image, $filter, ...$args);
+    } else {
+        $safeResult = \imagefilter($image, $filter);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $mode
+ * @return bool
+ *
+ */
+function imageflip(\GdImage $image, int $mode): bool
+{
+    error_clear_last();
+    $safeResult = \imageflip($image, $mode);
+    return $safeResult;
+}
+
+
+/**
+ * @param float $size
+ * @param float $angle
+ * @param string $font_filename
+ * @param string $string
+ * @param array $options
+ * @return array
+ * @throws ImageException
+ *
+ */
+function imageftbbox(float $size, float $angle, string $font_filename, string $string, array $options = []): array
+{
+    error_clear_last();
+    $safeResult = \imageftbbox($size, $angle, $font_filename, $string, $options);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param float $size
+ * @param float $angle
+ * @param int $x
+ * @param int $y
+ * @param int $color
+ * @param string $font_filename
+ * @param string $text
+ * @param array $options
+ * @return array
+ * @throws ImageException
+ *
+ */
+function imagefttext(\GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array
+{
+    error_clear_last();
+    $safeResult = \imagefttext($image, $size, $angle, $x, $y, $color, $font_filename, $text, $options);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param float $input_gamma
+ * @param float $output_gamma
+ * @return bool
+ *
+ */
+function imagegammacorrect(\GdImage $image, float $input_gamma, float $output_gamma): bool
+{
+    error_clear_last();
+    $safeResult = \imagegammacorrect($image, $input_gamma, $output_gamma);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @throws ImageException
+ *
+ */
+function imagegd(\GdImage $image, $file = null): void
+{
+    error_clear_last();
+    if ($file !== null) {
+        $safeResult = \imagegd($image, $file);
+    } else {
+        $safeResult = \imagegd($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int $chunk_size
+ * @param int $mode
+ * @throws ImageException
+ *
+ */
+function imagegd2(\GdImage $image, $file = null, int $chunk_size = 128, int $mode = IMG_GD2_RAW): void
+{
+    error_clear_last();
+    if ($mode !== IMG_GD2_RAW) {
+        $safeResult = \imagegd2($image, $file, $chunk_size, $mode);
+    } elseif ($chunk_size !== 128) {
+        $safeResult = \imagegd2($image, $file, $chunk_size);
+    } elseif ($file !== null) {
+        $safeResult = \imagegd2($image, $file);
+    } else {
+        $safeResult = \imagegd2($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @throws ImageException
+ *
+ */
+function imagegif(\GdImage $image, $file = null): void
+{
+    error_clear_last();
+    if ($file !== null) {
+        $safeResult = \imagegif($image, $file);
+    } else {
+        $safeResult = \imagegif($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagegrabscreen(): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagegrabscreen();
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $handle
+ * @param bool $client_area
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagegrabwindow(int $handle, bool $client_area = false): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagegrabwindow($handle, $client_area);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int $quality
+ * @throws ImageException
+ *
+ */
+function imagejpeg(\GdImage $image, $file = null, int $quality = -1): void
+{
+    error_clear_last();
+    if ($quality !== -1) {
+        $safeResult = \imagejpeg($image, $file, $quality);
+    } elseif ($file !== null) {
+        $safeResult = \imagejpeg($image, $file);
+    } else {
+        $safeResult = \imagejpeg($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $effect
+ * @return bool
+ *
+ */
+function imagelayereffect(\GdImage $image, int $effect): bool
+{
+    error_clear_last();
+    $safeResult = \imagelayereffect($image, $effect);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x1
+ * @param int $y1
+ * @param int $x2
+ * @param int $y2
+ * @param int $color
+ * @return bool
+ *
+ */
+function imageline(\GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imageline($image, $x1, $y1, $x2, $y2, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @return int
+ * @throws ImageException
+ *
+ */
+function imageloadfont(string $filename): int
+{
+    error_clear_last();
+    $safeResult = \imageloadfont($filename);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int $quality
+ * @param int $filters
+ * @throws ImageException
+ *
+ */
+function imagepng(\GdImage $image, $file = null, int $quality = -1, int $filters = -1): void
+{
+    error_clear_last();
+    if ($filters !== -1) {
+        $safeResult = \imagepng($image, $file, $quality, $filters);
+    } elseif ($quality !== -1) {
+        $safeResult = \imagepng($image, $file, $quality);
+    } elseif ($file !== null) {
+        $safeResult = \imagepng($image, $file);
+    } else {
+        $safeResult = \imagepng($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x1
+ * @param int $y1
+ * @param int $x2
+ * @param int $y2
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagerectangle(\GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagerectangle($image, $x1, $y1, $x2, $y2, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int|null $resolution_x
+ * @param int|null $resolution_y
+ * @return mixed
+ *
+ */
+function imageresolution(\GdImage $image, ?int $resolution_x = null, ?int $resolution_y = null)
+{
+    error_clear_last();
+    if ($resolution_y !== null) {
+        $safeResult = \imageresolution($image, $resolution_x, $resolution_y);
+    } elseif ($resolution_x !== null) {
+        $safeResult = \imageresolution($image, $resolution_x);
+    } else {
+        $safeResult = \imageresolution($image);
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param float $angle
+ * @param int $background_color
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagerotate(\GdImage $image, float $angle, int $background_color): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagerotate($image, $angle, $background_color);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param bool $enable
+ * @return bool
+ *
+ */
+function imagesavealpha(\GdImage $image, bool $enable): bool
+{
+    error_clear_last();
+    $safeResult = \imagesavealpha($image, $enable);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $width
+ * @param int $height
+ * @param int $mode
+ * @return \GdImage
+ * @throws ImageException
+ *
+ */
+function imagescale(\GdImage $image, int $width, int $height = -1, int $mode = IMG_BILINEAR_FIXED): \GdImage
+{
+    error_clear_last();
+    $safeResult = \imagescale($image, $width, $height, $mode);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param \GdImage $brush
+ * @return bool
+ *
+ */
+function imagesetbrush(\GdImage $image, \GdImage $brush): bool
+{
+    error_clear_last();
+    $safeResult = \imagesetbrush($image, $brush);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x1
+ * @param int $y1
+ * @param int $x2
+ * @param int $y2
+ * @return bool
+ *
+ */
+function imagesetclip(\GdImage $image, int $x1, int $y1, int $x2, int $y2): bool
+{
+    error_clear_last();
+    $safeResult = \imagesetclip($image, $x1, $y1, $x2, $y2);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $method
+ * @throws ImageException
+ *
+ */
+function imagesetinterpolation(\GdImage $image, int $method = IMG_BILINEAR_FIXED): void
+{
+    error_clear_last();
+    $safeResult = \imagesetinterpolation($image, $method);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $x
+ * @param int $y
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagesetpixel(\GdImage $image, int $x, int $y, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagesetpixel($image, $x, $y, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param array $style
+ * @throws ImageException
+ *
+ */
+function imagesetstyle(\GdImage $image, array $style): void
+{
+    error_clear_last();
+    $safeResult = \imagesetstyle($image, $style);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $thickness
+ * @return bool
+ *
+ */
+function imagesetthickness(\GdImage $image, int $thickness): bool
+{
+    error_clear_last();
+    $safeResult = \imagesetthickness($image, $thickness);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param \GdImage $tile
+ * @return bool
+ *
+ */
+function imagesettile(\GdImage $image, \GdImage $tile): bool
+{
+    error_clear_last();
+    $safeResult = \imagesettile($image, $tile);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $font
+ * @param int $x
+ * @param int $y
+ * @param string $string
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagestring(\GdImage $image, int $font, int $x, int $y, string $string, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagestring($image, $font, $x, $y, $string, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param int $font
+ * @param int $x
+ * @param int $y
+ * @param string $string
+ * @param int $color
+ * @return bool
+ *
+ */
+function imagestringup(\GdImage $image, int $font, int $x, int $y, string $string, int $color): bool
+{
+    error_clear_last();
+    $safeResult = \imagestringup($image, $font, $x, $y, $string, $color);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @return int
+ *
+ */
+function imagesx(\GdImage $image): int
+{
+    error_clear_last();
+    $safeResult = \imagesx($image);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @return int
+ *
+ */
+function imagesy(\GdImage $image): int
+{
+    error_clear_last();
+    $safeResult = \imagesy($image);
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param bool $dither
+ * @param int $num_colors
+ * @throws ImageException
+ *
+ */
+function imagetruecolortopalette(\GdImage $image, bool $dither, int $num_colors): void
+{
+    error_clear_last();
+    $safeResult = \imagetruecolortopalette($image, $dither, $num_colors);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param float $size
+ * @param float $angle
+ * @param string $font_filename
+ * @param string $string
+ * @param array $options
+ * @return array
+ * @throws ImageException
+ *
+ */
+function imagettfbbox(float $size, float $angle, string $font_filename, string $string, array $options = []): array
+{
+    error_clear_last();
+    $safeResult = \imagettfbbox($size, $angle, $font_filename, $string, $options);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param float $size
+ * @param float $angle
+ * @param int $x
+ * @param int $y
+ * @param int $color
+ * @param string $font_filename
+ * @param string $text
+ * @param array $options
+ * @return array
+ * @throws ImageException
+ *
+ */
+function imagettftext(\GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array
+{
+    error_clear_last();
+    $safeResult = \imagettftext($image, $size, $angle, $x, $y, $color, $font_filename, $text, $options);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int|null $foreground_color
+ * @throws ImageException
+ *
+ */
+function imagewbmp(\GdImage $image, $file = null, ?int $foreground_color = null): void
+{
+    error_clear_last();
+    if ($foreground_color !== null) {
+        $safeResult = \imagewbmp($image, $file, $foreground_color);
+    } elseif ($file !== null) {
+        $safeResult = \imagewbmp($image, $file);
+    } else {
+        $safeResult = \imagewbmp($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $file
+ * @param int $quality
+ * @throws ImageException
+ *
+ */
+function imagewebp(\GdImage $image, $file = null, int $quality = -1): void
+{
+    error_clear_last();
+    if ($quality !== -1) {
+        $safeResult = \imagewebp($image, $file, $quality);
+    } elseif ($file !== null) {
+        $safeResult = \imagewebp($image, $file);
+    } else {
+        $safeResult = \imagewebp($image);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \GdImage $image
+ * @param null|resource|string $filename
+ * @param int|null $foreground_color
+ * @throws ImageException
+ *
+ */
+function imagexbm(\GdImage $image, $filename, ?int $foreground_color = null): void
+{
+    error_clear_last();
+    if ($foreground_color !== null) {
+        $safeResult = \imagexbm($image, $filename, $foreground_color);
+    } else {
+        $safeResult = \imagexbm($image, $filename);
+    }
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $iptc_data
+ * @param string $filename
+ * @param int $spool
+ * @return bool|string
+ * @throws ImageException
+ *
+ */
+function iptcembed(string $iptc_data, string $filename, int $spool = 0)
+{
+    error_clear_last();
+    $safeResult = \iptcembed($iptc_data, $filename, $spool);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $iptc_block
+ * @return array
+ * @throws ImageException
+ *
+ */
+function iptcparse(string $iptc_block): array
+{
+    error_clear_last();
+    $safeResult = \iptcparse($iptc_block);
+    if ($safeResult === false) {
+        throw ImageException::createFromPhpError();
+    }
+    return $safeResult;
+}
diff --git a/generated/8.6/ldap.php b/generated/8.6/ldap.php
index b596de91..e1d38a4d 100644
--- a/generated/8.6/ldap.php
+++ b/generated/8.6/ldap.php
@@ -131,16 +131,12 @@ function ldap_control_paged_result($link, int $pagesize, bool $iscritical = fals
  * @param \LDAP\Connection $ldap
  * @param \LDAP\Result $result
  * @return int
- * @throws LdapException
  *
  */
 function ldap_count_entries(\LDAP\Connection $ldap, \LDAP\Result $result): int
 {
     error_clear_last();
     $safeResult = \ldap_count_entries($ldap, $result);
-    if ($safeResult === false) {
-        throw LdapException::createFromPhpError();
-    }
     return $safeResult;
 }
 
@@ -204,6 +200,38 @@ function ldap_exop_passwd(\LDAP\Connection $ldap, string $user = "", string $old
 }
 
 
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $request_oid
+ * @param null|string $request_data
+ * @param array|null $controls
+ * @param null|string $response_data
+ * @param null|string $response_oid
+ * @return \LDAP\Result|bool
+ * @throws LdapException
+ *
+ */
+function ldap_exop_sync(\LDAP\Connection $ldap, string $request_oid, ?string $request_data = null, ?array $controls = null, ?string &$response_data = null, ?string &$response_oid = null)
+{
+    error_clear_last();
+    if ($response_oid !== null) {
+        $safeResult = \ldap_exop_sync($ldap, $request_oid, $request_data, $controls, $response_data, $response_oid);
+    } elseif ($response_data !== null) {
+        $safeResult = \ldap_exop_sync($ldap, $request_oid, $request_data, $controls, $response_data);
+    } elseif ($controls !== null) {
+        $safeResult = \ldap_exop_sync($ldap, $request_oid, $request_data, $controls);
+    } elseif ($request_data !== null) {
+        $safeResult = \ldap_exop_sync($ldap, $request_oid, $request_data);
+    } else {
+        $safeResult = \ldap_exop_sync($ldap, $request_oid);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
 /**
  * @param \LDAP\Connection $ldap
  * @return bool|string
diff --git a/generated/8.6/litespeed.php b/generated/8.6/litespeed.php
new file mode 100644
index 00000000..a6a11a3f
--- /dev/null
+++ b/generated/8.6/litespeed.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\LitespeedException;
+
+/**
+ * @throws LitespeedException
+ *
+ */
+function litespeed_finish_request(): void
+{
+    error_clear_last();
+    $safeResult = \litespeed_finish_request();
+    if ($safeResult === false) {
+        throw LitespeedException::createFromPhpError();
+    }
+}
diff --git a/generated/8.6/pcntl.php b/generated/8.6/pcntl.php
index 55e1c605..6a1268f7 100644
--- a/generated/8.6/pcntl.php
+++ b/generated/8.6/pcntl.php
@@ -71,6 +71,28 @@ function pcntl_setcpuaffinity(?int $process_id = null, array $cpu_ids = []): voi
 }
 
 
+/**
+ * @param int|null $process_id
+ * @param int $nstype
+ * @throws PcntlException
+ *
+ */
+function pcntl_setns(?int $process_id = null, int $nstype = CLONE_NEWNET): void
+{
+    error_clear_last();
+    if ($nstype !== CLONE_NEWNET) {
+        $safeResult = \pcntl_setns($process_id, $nstype);
+    } elseif ($process_id !== null) {
+        $safeResult = \pcntl_setns($process_id);
+    } else {
+        $safeResult = \pcntl_setns();
+    }
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
 /**
  * @param int $priority
  * @param int|null $process_id
diff --git a/generated/8.6/pgsql.php b/generated/8.6/pgsql.php
new file mode 100644
index 00000000..10732a73
--- /dev/null
+++ b/generated/8.6/pgsql.php
@@ -0,0 +1,882 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\PgsqlException;
+
+/**
+ * @param \PgSql\Connection $connection
+ * @throws PgsqlException
+ *
+ */
+function pg_cancel_query(\PgSql\Connection $connection): void
+{
+    error_clear_last();
+    $safeResult = \pg_cancel_query($connection);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $user
+ * @param string $password
+ * @throws PgsqlException
+ *
+ */
+function pg_change_password(\PgSql\Connection $connection, string $user, string $password): void
+{
+    error_clear_last();
+    $safeResult = \pg_change_password($connection, $user, $password);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $connection_string
+ * @param int $flags
+ * @return \PgSql\Connection
+ * @throws PgsqlException
+ *
+ */
+function pg_connect(string $connection_string, int $flags = 0): \PgSql\Connection
+{
+    error_clear_last();
+    $safeResult = \pg_connect($connection_string, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @throws PgsqlException
+ *
+ */
+function pg_connection_reset(\PgSql\Connection $connection): void
+{
+    error_clear_last();
+    $safeResult = \pg_connection_reset($connection);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $values
+ * @param int $flags
+ * @return array
+ * @throws PgsqlException
+ *
+ */
+function pg_convert(\PgSql\Connection $connection, string $table_name, array $values, int $flags = 0): array
+{
+    error_clear_last();
+    $safeResult = \pg_convert($connection, $table_name, $values, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $rows
+ * @param string $separator
+ * @param string $null_as
+ * @throws PgsqlException
+ *
+ */
+function pg_copy_from(\PgSql\Connection $connection, string $table_name, array $rows, string $separator = "\t", string $null_as = "\\\\N"): void
+{
+    error_clear_last();
+    $safeResult = \pg_copy_from($connection, $table_name, $rows, $separator, $null_as);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param string $separator
+ * @param string $null_as
+ * @return array
+ * @throws PgsqlException
+ *
+ */
+function pg_copy_to(\PgSql\Connection $connection, string $table_name, string $separator = "\t", string $null_as = "\\\\N"): array
+{
+    error_clear_last();
+    $safeResult = \pg_copy_to($connection, $table_name, $separator, $null_as);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $conditions
+ * @param int $flags
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_delete(\PgSql\Connection $connection, string $table_name, array $conditions, int $flags = PGSQL_DML_EXEC)
+{
+    error_clear_last();
+    $safeResult = \pg_delete($connection, $table_name, $conditions, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection|null $connection
+ * @throws PgsqlException
+ *
+ */
+function pg_end_copy(?\PgSql\Connection $connection = null): void
+{
+    error_clear_last();
+    if ($connection !== null) {
+        $safeResult = \pg_end_copy($connection);
+    } else {
+        $safeResult = \pg_end_copy();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $string
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_escape_identifier(?\PgSql\Connection $connection = null, ?string $string = null): string
+{
+    error_clear_last();
+    if ($string !== null) {
+        $safeResult = \pg_escape_identifier($connection, $string);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_escape_identifier($connection);
+    } else {
+        $safeResult = \pg_escape_identifier();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $string
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_escape_literal(?\PgSql\Connection $connection = null, ?string $string = null): string
+{
+    error_clear_last();
+    if ($string !== null) {
+        $safeResult = \pg_escape_literal($connection, $string);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_escape_literal($connection);
+    } else {
+        $safeResult = \pg_escape_literal();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $statement_name
+ * @param array $params
+ * @return \PgSql\Result
+ * @throws PgsqlException
+ *
+ */
+function pg_execute(?\PgSql\Connection $connection = null, ?string $statement_name = null, ?array $params = null): \PgSql\Result
+{
+    error_clear_last();
+    if ($params !== null) {
+        $safeResult = \pg_execute($connection, $statement_name, $params);
+    } elseif ($statement_name !== null) {
+        $safeResult = \pg_execute($connection, $statement_name);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_execute($connection);
+    } else {
+        $safeResult = \pg_execute();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @param string $field
+ * @return int
+ * @throws PgsqlException
+ *
+ */
+function pg_field_num(\PgSql\Result $result, string $field): int
+{
+    error_clear_last();
+    $safeResult = \pg_field_num($result, $field);
+    if ($safeResult === -1) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @param int $field
+ * @param bool $oid_only
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_field_table(\PgSql\Result $result, int $field, bool $oid_only = false)
+{
+    error_clear_last();
+    $safeResult = \pg_field_table($result, $field, $oid_only);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_flush(\PgSql\Connection $connection)
+{
+    error_clear_last();
+    $safeResult = \pg_flush($connection);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @throws PgsqlException
+ *
+ */
+function pg_free_result(\PgSql\Result $result): void
+{
+    error_clear_last();
+    $safeResult = \pg_free_result($result);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection|null $connection
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_host(?\PgSql\Connection $connection = null): string
+{
+    error_clear_last();
+    if ($connection !== null) {
+        $safeResult = \pg_host($connection);
+    } else {
+        $safeResult = \pg_host();
+    }
+    if ($safeResult === '') {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $values
+ * @param int $flags
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_insert(\PgSql\Connection $connection, string $table_name, array $values, int $flags = PGSQL_DML_EXEC)
+{
+    error_clear_last();
+    $safeResult = \pg_insert($connection, $table_name, $values, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_last_oid(\PgSql\Result $result): string
+{
+    error_clear_last();
+    $safeResult = \pg_last_oid($result);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Lob $lob
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_close(\PgSql\Lob $lob): void
+{
+    error_clear_last();
+    $safeResult = \pg_lo_close($lob);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param int $oid
+ * @param string $filename
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_export(?\PgSql\Connection $connection = null, ?int $oid = null, ?string $filename = null): void
+{
+    error_clear_last();
+    if ($filename !== null) {
+        $safeResult = \pg_lo_export($connection, $oid, $filename);
+    } elseif ($oid !== null) {
+        $safeResult = \pg_lo_export($connection, $oid);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_lo_export($connection);
+    } else {
+        $safeResult = \pg_lo_export();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $filename
+ * @param  $oid
+ * @return int
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_import(?\PgSql\Connection $connection = null, ?string $filename = null, $oid = null): int
+{
+    error_clear_last();
+    if ($oid !== null) {
+        $safeResult = \pg_lo_import($connection, $filename, $oid);
+    } elseif ($filename !== null) {
+        $safeResult = \pg_lo_import($connection, $filename);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_lo_import($connection);
+    } else {
+        $safeResult = \pg_lo_import();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param int $oid
+ * @param string $mode
+ * @return \PgSql\Lob
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_open(\PgSql\Connection $connection, int $oid, string $mode): \PgSql\Lob
+{
+    error_clear_last();
+    $safeResult = \pg_lo_open($connection, $oid, $mode);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Lob $lob
+ * @param int $length
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_read(\PgSql\Lob $lob, int $length = 8192): string
+{
+    error_clear_last();
+    $safeResult = \pg_lo_read($lob, $length);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Lob $lob
+ * @param int $offset
+ * @param int $whence
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_seek(\PgSql\Lob $lob, int $offset, int $whence = SEEK_CUR): void
+{
+    error_clear_last();
+    $safeResult = \pg_lo_seek($lob, $offset, $whence);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Lob $lob
+ * @param int $size
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_truncate(\PgSql\Lob $lob, int $size): void
+{
+    error_clear_last();
+    $safeResult = \pg_lo_truncate($lob, $size);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param int $oid
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_unlink(\PgSql\Connection $connection, int $oid): void
+{
+    error_clear_last();
+    $safeResult = \pg_lo_unlink($connection, $oid);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Lob $lob
+ * @param string $data
+ * @param int|null $length
+ * @return int
+ * @throws PgsqlException
+ *
+ */
+function pg_lo_write(\PgSql\Lob $lob, string $data, ?int $length = null): int
+{
+    error_clear_last();
+    if ($length !== null) {
+        $safeResult = \pg_lo_write($lob, $data, $length);
+    } else {
+        $safeResult = \pg_lo_write($lob, $data);
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param bool $extended
+ * @return array
+ * @throws PgsqlException
+ *
+ */
+function pg_meta_data(\PgSql\Connection $connection, string $table_name, bool $extended = false): array
+{
+    error_clear_last();
+    $safeResult = \pg_meta_data($connection, $table_name, $extended);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $name
+ * @return string
+ * @throws PgsqlException
+ *
+ */
+function pg_parameter_status(?\PgSql\Connection $connection = null, ?string $name = null): string
+{
+    error_clear_last();
+    if ($name !== null) {
+        $safeResult = \pg_parameter_status($connection, $name);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_parameter_status($connection);
+    } else {
+        $safeResult = \pg_parameter_status();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $connection_string
+ * @param int $flags
+ * @return \PgSql\Connection
+ * @throws PgsqlException
+ *
+ */
+function pg_pconnect(string $connection_string, int $flags = 0): \PgSql\Connection
+{
+    error_clear_last();
+    $safeResult = \pg_pconnect($connection_string, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection|null $connection
+ * @throws PgsqlException
+ *
+ */
+function pg_ping(?\PgSql\Connection $connection = null): void
+{
+    error_clear_last();
+    if ($connection !== null) {
+        $safeResult = \pg_ping($connection);
+    } else {
+        $safeResult = \pg_ping();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $statement_name
+ * @param string $query
+ * @return \PgSql\Result
+ * @throws PgsqlException
+ *
+ */
+function pg_prepare(?\PgSql\Connection $connection = null, ?string $statement_name = null, ?string $query = null): \PgSql\Result
+{
+    error_clear_last();
+    if ($query !== null) {
+        $safeResult = \pg_prepare($connection, $statement_name, $query);
+    } elseif ($statement_name !== null) {
+        $safeResult = \pg_prepare($connection, $statement_name);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_prepare($connection);
+    } else {
+        $safeResult = \pg_prepare();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $query
+ * @throws PgsqlException
+ *
+ */
+function pg_put_line(?\PgSql\Connection $connection = null, ?string $query = null): void
+{
+    error_clear_last();
+    if ($query !== null) {
+        $safeResult = \pg_put_line($connection, $query);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_put_line($connection);
+    } else {
+        $safeResult = \pg_put_line();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $query
+ * @param array $params
+ * @return \PgSql\Result
+ * @throws PgsqlException
+ *
+ */
+function pg_query_params(?\PgSql\Connection $connection = null, ?string $query = null, ?array $params = null): \PgSql\Result
+{
+    error_clear_last();
+    if ($params !== null) {
+        $safeResult = \pg_query_params($connection, $query, $params);
+    } elseif ($query !== null) {
+        $safeResult = \pg_query_params($connection, $query);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_query_params($connection);
+    } else {
+        $safeResult = \pg_query_params();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $query
+ * @return \PgSql\Result
+ * @throws PgsqlException
+ *
+ */
+function pg_query(?\PgSql\Connection $connection = null, ?string $query = null): \PgSql\Result
+{
+    error_clear_last();
+    if ($query !== null) {
+        $safeResult = \pg_query($connection, $query);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_query($connection);
+    } else {
+        $safeResult = \pg_query();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @param int $field_code
+ * @return null|string
+ * @throws PgsqlException
+ *
+ */
+function pg_result_error_field(\PgSql\Result $result, int $field_code): ?string
+{
+    error_clear_last();
+    $safeResult = \pg_result_error_field($result, $field_code);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Result $result
+ * @param int $row
+ * @throws PgsqlException
+ *
+ */
+function pg_result_seek(\PgSql\Result $result, int $row): void
+{
+    error_clear_last();
+    $safeResult = \pg_result_seek($result, $row);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $conditions
+ * @param int $flags
+ * @param int $mode
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_select(\PgSql\Connection $connection, string $table_name, array $conditions = [], int $flags = PGSQL_DML_EXEC, int $mode = PGSQL_ASSOC)
+{
+    error_clear_last();
+    $safeResult = \pg_select($connection, $table_name, $conditions, $flags, $mode);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param int $size
+ * @throws PgsqlException
+ *
+ */
+function pg_set_chunked_rows_size(\PgSql\Connection $connection, int $size): void
+{
+    error_clear_last();
+    $safeResult = \pg_set_chunked_rows_size($connection, $size);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param int $verbosity
+ * @return int
+ * @throws PgsqlException
+ *
+ */
+function pg_set_error_verbosity(?\PgSql\Connection $connection = null, ?int $verbosity = null): int
+{
+    error_clear_last();
+    if ($verbosity !== null) {
+        $safeResult = \pg_set_error_verbosity($connection, $verbosity);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_set_error_verbosity($connection);
+    } else {
+        $safeResult = \pg_set_error_verbosity();
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @return resource
+ * @throws PgsqlException
+ *
+ */
+function pg_socket(\PgSql\Connection $connection)
+{
+    error_clear_last();
+    $safeResult = \pg_socket($connection);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @param string $mode
+ * @param \PgSql\Connection|null $connection
+ * @param int $trace_mode
+ * @throws PgsqlException
+ *
+ */
+function pg_trace(string $filename, string $mode = "w", ?\PgSql\Connection $connection = null, int $trace_mode = 0): void
+{
+    error_clear_last();
+    if ($trace_mode !== 0) {
+        $safeResult = \pg_trace($filename, $mode, $connection, $trace_mode);
+    } elseif ($connection !== null) {
+        $safeResult = \pg_trace($filename, $mode, $connection);
+    } else {
+        $safeResult = \pg_trace($filename, $mode);
+    }
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \PgSql\Connection $connection
+ * @param string $table_name
+ * @param array $values
+ * @param array $conditions
+ * @param int $flags
+ * @return mixed
+ * @throws PgsqlException
+ *
+ */
+function pg_update(\PgSql\Connection $connection, string $table_name, array $values, array $conditions, int $flags = PGSQL_DML_EXEC)
+{
+    error_clear_last();
+    $safeResult = \pg_update($connection, $table_name, $values, $conditions, $flags);
+    if ($safeResult === false) {
+        throw PgsqlException::createFromPhpError();
+    }
+    return $safeResult;
+}
diff --git a/generated/8.6/rector-migrate.php b/generated/8.6/rector-migrate.php
index c5145b2f..ba7a9cd9 100644
--- a/generated/8.6/rector-migrate.php
+++ b/generated/8.6/rector-migrate.php
@@ -315,23 +315,11 @@
             'imageaffine' => 'Safe\imageaffine',
             'imageaffinematrixconcat' => 'Safe\imageaffinematrixconcat',
             'imageaffinematrixget' => 'Safe\imageaffinematrixget',
-            'imagealphablending' => 'Safe\imagealphablending',
-            'imageantialias' => 'Safe\imageantialias',
-            'imagearc' => 'Safe\imagearc',
             'imageavif' => 'Safe\imageavif',
             'imagebmp' => 'Safe\imagebmp',
-            'imagechar' => 'Safe\imagechar',
-            'imagecharup' => 'Safe\imagecharup',
             'imagecolorat' => 'Safe\imagecolorat',
-            'imagecolordeallocate' => 'Safe\imagecolordeallocate',
-            'imagecolormatch' => 'Safe\imagecolormatch',
             'imagecolorset' => 'Safe\imagecolorset',
             'imageconvolution' => 'Safe\imageconvolution',
-            'imagecopy' => 'Safe\imagecopy',
-            'imagecopymerge' => 'Safe\imagecopymerge',
-            'imagecopymergegray' => 'Safe\imagecopymergegray',
-            'imagecopyresampled' => 'Safe\imagecopyresampled',
-            'imagecopyresized' => 'Safe\imagecopyresized',
             'imagecreate' => 'Safe\imagecreate',
             'imagecreatefromavif' => 'Safe\imagecreatefromavif',
             'imagecreatefrombmp' => 'Safe\imagecreatefrombmp',
@@ -350,43 +338,21 @@
             'imagecreatetruecolor' => 'Safe\imagecreatetruecolor',
             'imagecrop' => 'Safe\imagecrop',
             'imagecropauto' => 'Safe\imagecropauto',
-            'imagedashedline' => 'Safe\imagedashedline',
-            'imagedestroy' => 'Safe\imagedestroy',
-            'imageellipse' => 'Safe\imageellipse',
-            'imagefill' => 'Safe\imagefill',
-            'imagefilledarc' => 'Safe\imagefilledarc',
-            'imagefilledellipse' => 'Safe\imagefilledellipse',
-            'imagefilledrectangle' => 'Safe\imagefilledrectangle',
-            'imagefilltoborder' => 'Safe\imagefilltoborder',
             'imagefilter' => 'Safe\imagefilter',
-            'imageflip' => 'Safe\imageflip',
             'imageftbbox' => 'Safe\imageftbbox',
             'imagefttext' => 'Safe\imagefttext',
-            'imagegammacorrect' => 'Safe\imagegammacorrect',
             'imagegd' => 'Safe\imagegd',
             'imagegd2' => 'Safe\imagegd2',
             'imagegif' => 'Safe\imagegif',
             'imagegrabscreen' => 'Safe\imagegrabscreen',
             'imagegrabwindow' => 'Safe\imagegrabwindow',
             'imagejpeg' => 'Safe\imagejpeg',
-            'imagelayereffect' => 'Safe\imagelayereffect',
-            'imageline' => 'Safe\imageline',
             'imageloadfont' => 'Safe\imageloadfont',
             'imagepng' => 'Safe\imagepng',
-            'imagerectangle' => 'Safe\imagerectangle',
-            'imageresolution' => 'Safe\imageresolution',
             'imagerotate' => 'Safe\imagerotate',
-            'imagesavealpha' => 'Safe\imagesavealpha',
             'imagescale' => 'Safe\imagescale',
-            'imagesetbrush' => 'Safe\imagesetbrush',
-            'imagesetclip' => 'Safe\imagesetclip',
             'imagesetinterpolation' => 'Safe\imagesetinterpolation',
-            'imagesetpixel' => 'Safe\imagesetpixel',
             'imagesetstyle' => 'Safe\imagesetstyle',
-            'imagesetthickness' => 'Safe\imagesetthickness',
-            'imagesettile' => 'Safe\imagesettile',
-            'imagestring' => 'Safe\imagestring',
-            'imagestringup' => 'Safe\imagestringup',
             'imagetruecolortopalette' => 'Safe\imagetruecolortopalette',
             'imagettfbbox' => 'Safe\imagettfbbox',
             'imagettftext' => 'Safe\imagettftext',
@@ -458,11 +424,11 @@
             'ldap_compare' => 'Safe\ldap_compare',
             'ldap_control_paged_result' => 'Safe\ldap_control_paged_result',
             'ldap_control_paged_result_response' => 'Safe\ldap_control_paged_result_response',
-            'ldap_count_entries' => 'Safe\ldap_count_entries',
             'ldap_delete' => 'Safe\ldap_delete',
             'ldap_dn2ufn' => 'Safe\ldap_dn2ufn',
             'ldap_exop' => 'Safe\ldap_exop',
             'ldap_exop_passwd' => 'Safe\ldap_exop_passwd',
+            'ldap_exop_sync' => 'Safe\ldap_exop_sync',
             'ldap_exop_whoami' => 'Safe\ldap_exop_whoami',
             'ldap_explode_dn' => 'Safe\ldap_explode_dn',
             'ldap_first_attribute' => 'Safe\ldap_first_attribute',
@@ -485,6 +451,7 @@
             'ldap_set_option' => 'Safe\ldap_set_option',
             'ldap_unbind' => 'Safe\ldap_unbind',
             'link' => 'Safe\link',
+            'litespeed_finish_request' => 'Safe\litespeed_finish_request',
             'lstat' => 'Safe\lstat',
             'lzf_compress' => 'Safe\lzf_compress',
             'lzf_decompress' => 'Safe\lzf_decompress',
@@ -684,6 +651,7 @@
             'pcntl_getcpuaffinity' => 'Safe\pcntl_getcpuaffinity',
             'pcntl_getpriority' => 'Safe\pcntl_getpriority',
             'pcntl_setcpuaffinity' => 'Safe\pcntl_setcpuaffinity',
+            'pcntl_setns' => 'Safe\pcntl_setns',
             'pcntl_setpriority' => 'Safe\pcntl_setpriority',
             'pcntl_signal' => 'Safe\pcntl_signal',
             'pcntl_signal_dispatch' => 'Safe\pcntl_signal_dispatch',
@@ -692,6 +660,7 @@
             'pcntl_sigwaitinfo' => 'Safe\pcntl_sigwaitinfo',
             'pfsockopen' => 'Safe\pfsockopen',
             'pg_cancel_query' => 'Safe\pg_cancel_query',
+            'pg_change_password' => 'Safe\pg_change_password',
             'pg_connect' => 'Safe\pg_connect',
             'pg_connection_reset' => 'Safe\pg_connection_reset',
             'pg_convert' => 'Safe\pg_convert',
@@ -699,6 +668,8 @@
             'pg_copy_to' => 'Safe\pg_copy_to',
             'pg_delete' => 'Safe\pg_delete',
             'pg_end_copy' => 'Safe\pg_end_copy',
+            'pg_escape_identifier' => 'Safe\pg_escape_identifier',
+            'pg_escape_literal' => 'Safe\pg_escape_literal',
             'pg_execute' => 'Safe\pg_execute',
             'pg_field_num' => 'Safe\pg_field_num',
             'pg_field_table' => 'Safe\pg_field_table',
@@ -728,6 +699,7 @@
             'pg_result_seek' => 'Safe\pg_result_seek',
             'pg_select' => 'Safe\pg_select',
             'pg_set_chunked_rows_size' => 'Safe\pg_set_chunked_rows_size',
+            'pg_set_error_verbosity' => 'Safe\pg_set_error_verbosity',
             'pg_socket' => 'Safe\pg_socket',
             'pg_trace' => 'Safe\pg_trace',
             'pg_update' => 'Safe\pg_update',
@@ -763,7 +735,6 @@
             'preg_replace_callback' => 'Safe\preg_replace_callback',
             'preg_replace_callback_array' => 'Safe\preg_replace_callback_array',
             'preg_split' => 'Safe\preg_split',
-            'proc_close' => 'Safe\proc_close',
             'proc_nice' => 'Safe\proc_nice',
             'proc_open' => 'Safe\proc_open',
             'pspell_add_to_personal' => 'Safe\pspell_add_to_personal',
@@ -969,16 +940,12 @@
             'sodium_crypto_aead_aegis256_decrypt' => 'Safe\sodium_crypto_aead_aegis256_decrypt',
             'sodium_crypto_aead_aes256gcm_decrypt' => 'Safe\sodium_crypto_aead_aes256gcm_decrypt',
             'sodium_crypto_aead_chacha20poly1305_decrypt' => 'Safe\sodium_crypto_aead_chacha20poly1305_decrypt',
-            'sodium_crypto_aead_chacha20poly1305_encrypt' => 'Safe\sodium_crypto_aead_chacha20poly1305_encrypt',
             'sodium_crypto_aead_chacha20poly1305_ietf_decrypt' => 'Safe\sodium_crypto_aead_chacha20poly1305_ietf_decrypt',
-            'sodium_crypto_aead_chacha20poly1305_ietf_encrypt' => 'Safe\sodium_crypto_aead_chacha20poly1305_ietf_encrypt',
             'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt' => 'Safe\sodium_crypto_aead_xchacha20poly1305_ietf_decrypt',
-            'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt' => 'Safe\sodium_crypto_aead_xchacha20poly1305_ietf_encrypt',
             'sodium_crypto_box_open' => 'Safe\sodium_crypto_box_open',
             'sodium_crypto_box_seal_open' => 'Safe\sodium_crypto_box_seal_open',
             'sodium_crypto_secretbox_open' => 'Safe\sodium_crypto_secretbox_open',
             'sodium_crypto_sign_open' => 'Safe\sodium_crypto_sign_open',
-            'sodium_crypto_stream_xchacha20_xor_ic' => 'Safe\sodium_crypto_stream_xchacha20_xor_ic',
             'solr_get_version' => 'Safe\solr_get_version',
             'spl_autoload_register' => 'Safe\spl_autoload_register',
             'spl_autoload_unregister' => 'Safe\spl_autoload_unregister',
@@ -1006,6 +973,7 @@
             'ssh2_auth_agent' => 'Safe\ssh2_auth_agent',
             'ssh2_auth_hostbased_file' => 'Safe\ssh2_auth_hostbased_file',
             'ssh2_auth_password' => 'Safe\ssh2_auth_password',
+            'ssh2_auth_pubkey' => 'Safe\ssh2_auth_pubkey',
             'ssh2_auth_pubkey_file' => 'Safe\ssh2_auth_pubkey_file',
             'ssh2_connect' => 'Safe\ssh2_connect',
             'ssh2_disconnect' => 'Safe\ssh2_disconnect',
@@ -1020,9 +988,13 @@
             'ssh2_send_eof' => 'Safe\ssh2_send_eof',
             'ssh2_sftp' => 'Safe\ssh2_sftp',
             'ssh2_sftp_chmod' => 'Safe\ssh2_sftp_chmod',
+            'ssh2_sftp_lstat' => 'Safe\ssh2_sftp_lstat',
             'ssh2_sftp_mkdir' => 'Safe\ssh2_sftp_mkdir',
+            'ssh2_sftp_readlink' => 'Safe\ssh2_sftp_readlink',
+            'ssh2_sftp_realpath' => 'Safe\ssh2_sftp_realpath',
             'ssh2_sftp_rename' => 'Safe\ssh2_sftp_rename',
             'ssh2_sftp_rmdir' => 'Safe\ssh2_sftp_rmdir',
+            'ssh2_sftp_stat' => 'Safe\ssh2_sftp_stat',
             'ssh2_sftp_symlink' => 'Safe\ssh2_sftp_symlink',
             'ssh2_sftp_unlink' => 'Safe\ssh2_sftp_unlink',
             'ssh2_shell' => 'Safe\ssh2_shell',
diff --git a/generated/8.6/sodium.php b/generated/8.6/sodium.php
new file mode 100644
index 00000000..20fcc321
--- /dev/null
+++ b/generated/8.6/sodium.php
@@ -0,0 +1,310 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\SodiumException;
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_aegis128l_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_aegis128l_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_aegis256_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_aegis256_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_aes256gcm_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_aes256gcm_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_chacha20poly1305_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_chacha20poly1305_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $message
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ *
+ */
+function sodium_crypto_aead_chacha20poly1305_encrypt(string $message, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_chacha20poly1305_encrypt($message, $additional_data, $nonce, $key);
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_chacha20poly1305_ietf_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_chacha20poly1305_ietf_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $message
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ *
+ */
+function sodium_crypto_aead_chacha20poly1305_ietf_encrypt(string $message, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $additional_data, $nonce, $key);
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(string $ciphertext, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($ciphertext, $additional_data, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $message
+ * @param string $additional_data
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ *
+ */
+function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(string $message, string $additional_data, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $additional_data, $nonce, $key);
+    return $safeResult;
+}
+
+
+/**
+ * @param string $mac
+ * @param string $message
+ * @param string $key
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_auth_verify(string $mac, string $message, string $key): void
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_auth_verify($mac, $message, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $nonce
+ * @param string $key_pair
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_box_open(string $ciphertext, string $nonce, string $key_pair): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_box_open($ciphertext, $nonce, $key_pair);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $key_pair
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_box_seal_open(string $ciphertext, string $key_pair): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_box_seal_open($ciphertext, $key_pair);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param non-empty-string $state
+ * @param string $message
+ * @return bool
+ *
+ */
+function sodium_crypto_generichash_update(string &$state, string $message): bool
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_generichash_update($state, $message);
+    return $safeResult;
+}
+
+
+/**
+ * @param string $ciphertext
+ * @param string $nonce
+ * @param string $key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_secretbox_open(string $ciphertext, string $nonce, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_secretbox_open($ciphertext, $nonce, $key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $signed_message
+ * @param non-empty-string $public_key
+ * @return string
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_sign_open(string $signed_message, string $public_key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_sign_open($signed_message, $public_key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param non-empty-string $signature
+ * @param string $message
+ * @param non-empty-string $public_key
+ * @throws SodiumException
+ *
+ */
+function sodium_crypto_sign_verify_detached(string $signature, string $message, string $public_key): void
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_sign_verify_detached($signature, $message, $public_key);
+    if ($safeResult === false) {
+        throw SodiumException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $message
+ * @param string $nonce
+ * @param int $counter
+ * @param string $key
+ * @return string
+ *
+ */
+function sodium_crypto_stream_xchacha20_xor_ic(string $message, string $nonce, int $counter, string $key): string
+{
+    error_clear_last();
+    $safeResult = \sodium_crypto_stream_xchacha20_xor_ic($message, $nonce, $counter, $key);
+    return $safeResult;
+}
diff --git a/generated/8.6/ssh2.php b/generated/8.6/ssh2.php
new file mode 100644
index 00000000..d09d97a8
--- /dev/null
+++ b/generated/8.6/ssh2.php
@@ -0,0 +1,558 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\Ssh2Exception;
+
+/**
+ * @param resource $session
+ * @param string $username
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_auth_agent($session, string $username): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_auth_agent($session, $username);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $username
+ * @param string $hostname
+ * @param string $pubkeyfile
+ * @param string $privkeyfile
+ * @param string $passphrase
+ * @param string $local_username
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_auth_hostbased_file($session, string $username, string $hostname, string $pubkeyfile, string $privkeyfile, ?string $passphrase = null, ?string $local_username = null): void
+{
+    error_clear_last();
+    if ($local_username !== null) {
+        $safeResult = \ssh2_auth_hostbased_file($session, $username, $hostname, $pubkeyfile, $privkeyfile, $passphrase, $local_username);
+    } elseif ($passphrase !== null) {
+        $safeResult = \ssh2_auth_hostbased_file($session, $username, $hostname, $pubkeyfile, $privkeyfile, $passphrase);
+    } else {
+        $safeResult = \ssh2_auth_hostbased_file($session, $username, $hostname, $pubkeyfile, $privkeyfile);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $username
+ * @param string $password
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_auth_password($session, string $username, string $password): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_auth_password($session, $username, $password);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $username
+ * @param string $pubkeyfile
+ * @param string $privkeyfile
+ * @param string $passphrase
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_auth_pubkey_file($session, string $username, string $pubkeyfile, string $privkeyfile, ?string $passphrase = null): void
+{
+    error_clear_last();
+    if ($passphrase !== null) {
+        $safeResult = \ssh2_auth_pubkey_file($session, $username, $pubkeyfile, $privkeyfile, $passphrase);
+    } else {
+        $safeResult = \ssh2_auth_pubkey_file($session, $username, $pubkeyfile, $privkeyfile);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $username
+ * @param string $pubkey
+ * @param string $privkey
+ * @param string $passphrase
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_auth_pubkey($session, string $username, string $pubkey, string $privkey, ?string $passphrase = null): void
+{
+    error_clear_last();
+    if ($passphrase !== null) {
+        $safeResult = \ssh2_auth_pubkey($session, $username, $pubkey, $privkey, $passphrase);
+    } else {
+        $safeResult = \ssh2_auth_pubkey($session, $username, $pubkey, $privkey);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $host
+ * @param int $port
+ * @param array $methods
+ * @param array $callbacks
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_connect(string $host, int $port = 22, ?array $methods = null, ?array $callbacks = null)
+{
+    error_clear_last();
+    if ($callbacks !== null) {
+        $safeResult = \ssh2_connect($host, $port, $methods, $callbacks);
+    } elseif ($methods !== null) {
+        $safeResult = \ssh2_connect($host, $port, $methods);
+    } else {
+        $safeResult = \ssh2_connect($host, $port);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $session
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_disconnect($session): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_disconnect($session);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $command
+ * @param string $pty
+ * @param array $env
+ * @param int $width
+ * @param int $height
+ * @param int $width_height_type
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_exec($session, string $command, ?string $pty = null, ?array $env = null, int $width = 80, int $height = 25, int $width_height_type = SSH2_TERM_UNIT_CHARS)
+{
+    error_clear_last();
+    if ($width_height_type !== SSH2_TERM_UNIT_CHARS) {
+        $safeResult = \ssh2_exec($session, $command, $pty, $env, $width, $height, $width_height_type);
+    } elseif ($height !== 25) {
+        $safeResult = \ssh2_exec($session, $command, $pty, $env, $width, $height);
+    } elseif ($width !== 80) {
+        $safeResult = \ssh2_exec($session, $command, $pty, $env, $width);
+    } elseif ($env !== null) {
+        $safeResult = \ssh2_exec($session, $command, $pty, $env);
+    } elseif ($pty !== null) {
+        $safeResult = \ssh2_exec($session, $command, $pty);
+    } else {
+        $safeResult = \ssh2_exec($session, $command);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $listener
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_forward_accept($listener)
+{
+    error_clear_last();
+    $safeResult = \ssh2_forward_accept($listener);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $session
+ * @param int $port
+ * @param string $host
+ * @param int $max_connections
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_forward_listen($session, int $port, ?string $host = null, int $max_connections = 16)
+{
+    error_clear_last();
+    if ($max_connections !== 16) {
+        $safeResult = \ssh2_forward_listen($session, $port, $host, $max_connections);
+    } elseif ($host !== null) {
+        $safeResult = \ssh2_forward_listen($session, $port, $host);
+    } else {
+        $safeResult = \ssh2_forward_listen($session, $port);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $pkey
+ * @param string $algoname
+ * @param string $blob
+ * @param bool $overwrite
+ * @param array $attributes
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_publickey_add($pkey, string $algoname, string $blob, bool $overwrite = false, ?array $attributes = null): void
+{
+    error_clear_last();
+    if ($attributes !== null) {
+        $safeResult = \ssh2_publickey_add($pkey, $algoname, $blob, $overwrite, $attributes);
+    } else {
+        $safeResult = \ssh2_publickey_add($pkey, $algoname, $blob, $overwrite);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_publickey_init($session)
+{
+    error_clear_last();
+    $safeResult = \ssh2_publickey_init($session);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $pkey
+ * @param string $algoname
+ * @param string $blob
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_publickey_remove($pkey, string $algoname, string $blob): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_publickey_remove($pkey, $algoname, $blob);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $remote_file
+ * @param string $local_file
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_scp_recv($session, string $remote_file, string $local_file): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_scp_recv($session, $remote_file, $local_file);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @param string $local_file
+ * @param string $remote_file
+ * @param int $create_mode
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_scp_send($session, string $local_file, string $remote_file, int $create_mode = 0644): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_scp_send($session, $local_file, $remote_file, $create_mode);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $channel
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_send_eof($channel): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_send_eof($channel);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $filename
+ * @param int $mode
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_chmod($sftp, string $filename, int $mode): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_chmod($sftp, $filename, $mode);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $path
+ * @return array
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_lstat($sftp, string $path): array
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_lstat($sftp, $path);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $dirname
+ * @param int $mode
+ * @param bool $recursive
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_mkdir($sftp, string $dirname, int $mode = 0777, bool $recursive = false): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_mkdir($sftp, $dirname, $mode, $recursive);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $link
+ * @return string
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_readlink($sftp, string $link): string
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_readlink($sftp, $link);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $filename
+ * @return string
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_realpath($sftp, string $filename): string
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_realpath($sftp, $filename);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $from
+ * @param string $to
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_rename($sftp, string $from, string $to): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_rename($sftp, $from, $to);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $dirname
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_rmdir($sftp, string $dirname): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_rmdir($sftp, $dirname);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $path
+ * @return array
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_stat($sftp, string $path): array
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_stat($sftp, $path);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $target
+ * @param string $link
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_symlink($sftp, string $target, string $link): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_symlink($sftp, $target, $link);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $sftp
+ * @param string $filename
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp_unlink($sftp, string $filename): void
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp_unlink($sftp, $filename);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $session
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_sftp($session)
+{
+    error_clear_last();
+    $safeResult = \ssh2_sftp($session);
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $session
+ * @param string $termtype
+ * @param array|null $env
+ * @param int $width
+ * @param int $height
+ * @param int $width_height_type
+ * @return resource
+ * @throws Ssh2Exception
+ *
+ */
+function ssh2_shell($session, string $termtype = "vanilla", ?array $env = null, int $width = 80, int $height = 25, int $width_height_type = SSH2_TERM_UNIT_CHARS)
+{
+    error_clear_last();
+    if ($width_height_type !== SSH2_TERM_UNIT_CHARS) {
+        $safeResult = \ssh2_shell($session, $termtype, $env, $width, $height, $width_height_type);
+    } elseif ($height !== 25) {
+        $safeResult = \ssh2_shell($session, $termtype, $env, $width, $height);
+    } elseif ($width !== 80) {
+        $safeResult = \ssh2_shell($session, $termtype, $env, $width);
+    } elseif ($env !== null) {
+        $safeResult = \ssh2_shell($session, $termtype, $env);
+    } else {
+        $safeResult = \ssh2_shell($session, $termtype);
+    }
+    if ($safeResult === false) {
+        throw Ssh2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
diff --git a/generated/8.6/stream.php b/generated/8.6/stream.php
new file mode 100644
index 00000000..1a4a2529
--- /dev/null
+++ b/generated/8.6/stream.php
@@ -0,0 +1,490 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\StreamException;
+
+/**
+ * @param resource $context
+ * @param array $options
+ * @return true
+ * @throws StreamException
+ *
+ */
+function stream_context_set_options($context, array $options): void
+{
+    error_clear_last();
+    $safeResult = \stream_context_set_options($context, $options);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $context
+ * @param array $params
+ * @throws StreamException
+ *
+ */
+function stream_context_set_params($context, array $params): void
+{
+    error_clear_last();
+    $safeResult = \stream_context_set_params($context, $params);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $from
+ * @param resource $to
+ * @param int|null $length
+ * @param int $offset
+ * @return int
+ * @throws StreamException
+ *
+ */
+function stream_copy_to_stream($from, $to, ?int $length = null, int $offset = 0): int
+{
+    error_clear_last();
+    if ($offset !== 0) {
+        $safeResult = \stream_copy_to_stream($from, $to, $length, $offset);
+    } elseif ($length !== null) {
+        $safeResult = \stream_copy_to_stream($from, $to, $length);
+    } else {
+        $safeResult = \stream_copy_to_stream($from, $to);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param string $filter_name
+ * @param int $mode
+ * @param mixed $params
+ * @return resource
+ * @throws StreamException
+ *
+ */
+function stream_filter_append($stream, string $filter_name, ?int $mode = null, $params = null)
+{
+    error_clear_last();
+    if ($params !== null) {
+        $safeResult = \stream_filter_append($stream, $filter_name, $mode, $params);
+    } elseif ($mode !== null) {
+        $safeResult = \stream_filter_append($stream, $filter_name, $mode);
+    } else {
+        $safeResult = \stream_filter_append($stream, $filter_name);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param string $filter_name
+ * @param int $mode
+ * @param mixed $params
+ * @return resource
+ * @throws StreamException
+ *
+ */
+function stream_filter_prepend($stream, string $filter_name, ?int $mode = null, $params = null)
+{
+    error_clear_last();
+    if ($params !== null) {
+        $safeResult = \stream_filter_prepend($stream, $filter_name, $mode, $params);
+    } elseif ($mode !== null) {
+        $safeResult = \stream_filter_prepend($stream, $filter_name, $mode);
+    } else {
+        $safeResult = \stream_filter_prepend($stream, $filter_name);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filter_name
+ * @param string $class
+ * @throws StreamException
+ *
+ */
+function stream_filter_register(string $filter_name, string $class): void
+{
+    error_clear_last();
+    $safeResult = \stream_filter_register($filter_name, $class);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $stream_filter
+ * @throws StreamException
+ *
+ */
+function stream_filter_remove($stream_filter): void
+{
+    error_clear_last();
+    $safeResult = \stream_filter_remove($stream_filter);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $stream
+ * @param int|null $length
+ * @param int $offset
+ * @return string
+ * @throws StreamException
+ *
+ */
+function stream_get_contents($stream, ?int $length = null, int $offset = -1): string
+{
+    error_clear_last();
+    if ($offset !== -1) {
+        $safeResult = \stream_get_contents($stream, $length, $offset);
+    } elseif ($length !== null) {
+        $safeResult = \stream_get_contents($stream, $length);
+    } else {
+        $safeResult = \stream_get_contents($stream);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param int $length
+ * @param string $ending
+ * @return string
+ * @throws StreamException
+ *
+ */
+function stream_get_line($stream, int $length, string $ending = ""): string
+{
+    error_clear_last();
+    $safeResult = \stream_get_line($stream, $length, $ending);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @throws StreamException
+ *
+ */
+function stream_isatty($stream): void
+{
+    error_clear_last();
+    $safeResult = \stream_isatty($stream);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $filename
+ * @return string
+ * @throws StreamException
+ *
+ */
+function stream_resolve_include_path(string $filename): string
+{
+    error_clear_last();
+    $safeResult = \stream_resolve_include_path($filename);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param bool $enable
+ * @throws StreamException
+ *
+ */
+function stream_set_blocking($stream, bool $enable): void
+{
+    error_clear_last();
+    $safeResult = \stream_set_blocking($stream, $enable);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $stream
+ * @param int $seconds
+ * @param int $microseconds
+ * @throws StreamException
+ *
+ */
+function stream_set_timeout($stream, int $seconds, int $microseconds = 0): void
+{
+    error_clear_last();
+    $safeResult = \stream_set_timeout($stream, $seconds, $microseconds);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $socket
+ * @param float|null $timeout
+ * @param null|string $peer_name
+ * @return resource
+ * @throws StreamException
+ *
+ */
+function stream_socket_accept($socket, ?float $timeout = null, ?string &$peer_name = null)
+{
+    error_clear_last();
+    if ($peer_name !== null) {
+        $safeResult = \stream_socket_accept($socket, $timeout, $peer_name);
+    } elseif ($timeout !== null) {
+        $safeResult = \stream_socket_accept($socket, $timeout);
+    } else {
+        $safeResult = \stream_socket_accept($socket);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $address
+ * @param int|null $error_code
+ * @param null|string $error_message
+ * @param float|null $timeout
+ * @param int-mask $flags
+ * @param null|resource $context
+ * @return resource
+ * @throws StreamException
+ *
+ */
+function stream_socket_client(string $address, ?int &$error_code = null, ?string &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null)
+{
+    error_clear_last();
+    if ($context !== null) {
+        $safeResult = \stream_socket_client($address, $error_code, $error_message, $timeout, $flags, $context);
+    } elseif ($flags !== STREAM_CLIENT_CONNECT) {
+        $safeResult = \stream_socket_client($address, $error_code, $error_message, $timeout, $flags);
+    } elseif ($timeout !== null) {
+        $safeResult = \stream_socket_client($address, $error_code, $error_message, $timeout);
+    } else {
+        $safeResult = \stream_socket_client($address, $error_code, $error_message);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $socket
+ * @param bool $remote
+ * @return string
+ * @throws StreamException
+ *
+ */
+function stream_socket_get_name($socket, bool $remote): string
+{
+    error_clear_last();
+    $safeResult = \stream_socket_get_name($socket, $remote);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $domain
+ * @param int $type
+ * @param int $protocol
+ * @return resource[]
+ * @throws StreamException
+ *
+ */
+function stream_socket_pair(int $domain, int $type, int $protocol): array
+{
+    error_clear_last();
+    $safeResult = \stream_socket_pair($domain, $type, $protocol);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $socket
+ * @param int $length
+ * @param int $flags
+ * @param null|string $address
+ * @return string
+ * @throws StreamException
+ *
+ */
+function stream_socket_recvfrom($socket, int $length, int $flags = 0, ?string &$address = null): string
+{
+    error_clear_last();
+    $safeResult = \stream_socket_recvfrom($socket, $length, $flags, $address);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $socket
+ * @param string $data
+ * @param int $flags
+ * @param string $address
+ * @return int
+ * @throws StreamException
+ *
+ */
+function stream_socket_sendto($socket, string $data, int $flags = 0, string $address = ""): int
+{
+    error_clear_last();
+    $safeResult = \stream_socket_sendto($socket, $data, $flags, $address);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $address
+ * @param int|null $error_code
+ * @param null|string $error_message
+ * @param int $flags
+ * @param null|resource $context
+ * @return resource
+ * @throws StreamException
+ *
+ */
+function stream_socket_server(string $address, ?int &$error_code = null, ?string &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null)
+{
+    error_clear_last();
+    if ($context !== null) {
+        $safeResult = \stream_socket_server($address, $error_code, $error_message, $flags, $context);
+    } else {
+        $safeResult = \stream_socket_server($address, $error_code, $error_message, $flags);
+    }
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param int $mode
+ * @throws StreamException
+ *
+ */
+function stream_socket_shutdown($stream, int $mode): void
+{
+    error_clear_last();
+    $safeResult = \stream_socket_shutdown($stream, $mode);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $stream
+ * @throws StreamException
+ *
+ */
+function stream_supports_lock($stream): void
+{
+    error_clear_last();
+    $safeResult = \stream_supports_lock($stream);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $protocol
+ * @param string $class
+ * @param int $flags
+ * @throws StreamException
+ *
+ */
+function stream_wrapper_register(string $protocol, string $class, int $flags = 0): void
+{
+    error_clear_last();
+    $safeResult = \stream_wrapper_register($protocol, $class, $flags);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $protocol
+ * @throws StreamException
+ *
+ */
+function stream_wrapper_restore(string $protocol): void
+{
+    error_clear_last();
+    $safeResult = \stream_wrapper_restore($protocol);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $protocol
+ * @throws StreamException
+ *
+ */
+function stream_wrapper_unregister(string $protocol): void
+{
+    error_clear_last();
+    $safeResult = \stream_wrapper_unregister($protocol);
+    if ($safeResult === false) {
+        throw StreamException::createFromPhpError();
+    }
+}
diff --git a/generated/Exceptions/LitespeedException.php b/generated/Exceptions/LitespeedException.php
new file mode 100644
index 00000000..73271afc
--- /dev/null
+++ b/generated/Exceptions/LitespeedException.php
@@ -0,0 +1,11 @@
+<?php
+namespace Safe\Exceptions;
+
+class LitespeedException extends \ErrorException implements SafeExceptionInterface
+{
+    public static function createFromPhpError(): self
+    {
+        $error = error_get_last();
+        return new self($error['message'] ?? 'An error occurred', 0, $error['type'] ?? 1);
+    }
+}
diff --git a/generated/exec.php b/generated/exec.php
index 4a573bb6..893111cd 100644
--- a/generated/exec.php
+++ b/generated/exec.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.2/exec.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.2/exec.php';
+    require_once __DIR__ . '/8.6/exec.php';
 }
diff --git a/generated/image.php b/generated/image.php
index 66a2837f..94cd25da 100644
--- a/generated/image.php
+++ b/generated/image.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.4/image.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.4/image.php';
+    require_once __DIR__ . '/8.6/image.php';
 }
diff --git a/generated/litespeed.php b/generated/litespeed.php
new file mode 100644
index 00000000..bc8febe1
--- /dev/null
+++ b/generated/litespeed.php
@@ -0,0 +1,5 @@
+<?php
+
+if (str_starts_with(PHP_VERSION, "8.6.")) {
+    require_once __DIR__ . '/8.6/litespeed.php';
+}
diff --git a/generated/pgsql.php b/generated/pgsql.php
index 972a8015..f64dca89 100644
--- a/generated/pgsql.php
+++ b/generated/pgsql.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.4/pgsql.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.4/pgsql.php';
+    require_once __DIR__ . '/8.6/pgsql.php';
 }
diff --git a/generated/sodium.php b/generated/sodium.php
index fdffb92a..a8813492 100644
--- a/generated/sodium.php
+++ b/generated/sodium.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.4/sodium.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.4/sodium.php';
+    require_once __DIR__ . '/8.6/sodium.php';
 }
diff --git a/generated/ssh2.php b/generated/ssh2.php
index 848a1ecb..ec440d35 100644
--- a/generated/ssh2.php
+++ b/generated/ssh2.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.2/ssh2.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.2/ssh2.php';
+    require_once __DIR__ . '/8.6/ssh2.php';
 }
diff --git a/generated/stream.php b/generated/stream.php
index cc60d0de..78db2d04 100644
--- a/generated/stream.php
+++ b/generated/stream.php
@@ -16,5 +16,5 @@
     require_once __DIR__ . '/8.4/stream.php';
 }
 if (str_starts_with(PHP_VERSION, "8.6.")) {
-    require_once __DIR__ . '/8.4/stream.php';
+    require_once __DIR__ . '/8.6/stream.php';
 }

From dc423bf3c172cadcfcf7250e305ae1bcfd5561d5 Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Thu, 9 Jul 2026 21:25:09 +0100
Subject: [PATCH 3/3] fix type errors revealed by recent phpstan

---
 lib/DateTimeImmutable.php | 1 +
 lib/special_cases.php     | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/DateTimeImmutable.php b/lib/DateTimeImmutable.php
index f1113998..8a240e8d 100644
--- a/lib/DateTimeImmutable.php
+++ b/lib/DateTimeImmutable.php
@@ -257,6 +257,7 @@ public static function createFromInterface(\DateTimeInterface $object): self
      * @param mixed[] $array
      * @return DateTimeImmutable
      */
+    #[\ReturnTypeWillChange]
     public static function __set_state($array): self
     {
         return self::createFromRegular(parent::__set_state($array));
diff --git a/lib/special_cases.php b/lib/special_cases.php
index 29c182ce..7e8ee7d3 100644
--- a/lib/special_cases.php
+++ b/lib/special_cases.php
@@ -535,7 +535,7 @@ function ftp_raw(\FTP\Connection $ftp, string $command): array
  * should be instantiated, it'll be called. To disable this feature just
  * empty this setting.
  *
- * @param mixed[] $options [optional]
+ * @param array{allowed_classes?: array<string>|bool} $options [optional]
  * Any options to be provided to unserialize(), as an associative array.
  *
  * The 'allowed_classes' option key may be set to a value that is