Stand: SMTP-Test, Admin-Mail-Tab, Notifiable-Fix, Lazy-Quill

- Fix: Notifiable-Trait zum User-Model hinzugefuegt (behebt notify()-500er)
- Installer: SMTP-Verbindungstest mit EsmtpTransport + Ueberspringen-Link
- Admin: Neuer E-Mail-Tab mit SMTP-Konfiguration + Verbindungstest
- Admin: Lazy Quill-Initialisierung (nur sichtbare Locale wird geladen)
- Uebersetzungen: 17 neue Mail-Keys in allen 6 Sprachen

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

vendor/thecodingmachine/safe/generated/8.6/ldap.php

@@ -0,0 +1,666 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\LdapException;
+
+/**
+ * @param string $value
+ * @return string
+ * @throws LdapException
+ *
+ */
+function ldap_8859_to_t61(string $value): string
+{
+    error_clear_last();
+    $safeResult = \ldap_8859_to_t61($value);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array $entry
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_add(\LDAP\Connection $ldap, string $dn, array $entry, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_add($ldap, $dn, $entry, $controls);
+    } else {
+        $safeResult = \ldap_add($ldap, $dn, $entry);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param null|string $dn
+ * @param null|string $password
+ * @throws LdapException
+ *
+ */
+function ldap_bind(\LDAP\Connection $ldap, ?string $dn = null, ?string $password = null): void
+{
+    error_clear_last();
+    if ($password !== null) {
+        $safeResult = \ldap_bind($ldap, $dn, $password);
+    } elseif ($dn !== null) {
+        $safeResult = \ldap_bind($ldap, $dn);
+    } else {
+        $safeResult = \ldap_bind($ldap);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param string $attribute
+ * @param string $value
+ * @param array|null $controls
+ * @return bool
+ * @throws LdapException
+ *
+ */
+function ldap_compare(\LDAP\Connection $ldap, string $dn, string $attribute, string $value, ?array $controls = null): bool
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_compare($ldap, $dn, $attribute, $value, $controls);
+    } else {
+        $safeResult = \ldap_compare($ldap, $dn, $attribute, $value);
+    }
+    if ($safeResult === -1) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $link
+ * @param resource $result
+ * @param null|string $cookie
+ * @param int|null $estimated
+ * @throws LdapException
+ *
+ */
+function ldap_control_paged_result_response($link, $result, ?string &$cookie = null, ?int &$estimated = null): void
+{
+    error_clear_last();
+    $safeResult = \ldap_control_paged_result_response($link, $result, $cookie, $estimated);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $link
+ * @param int $pagesize
+ * @param bool $iscritical
+ * @param string $cookie
+ * @throws LdapException
+ *
+ */
+function ldap_control_paged_result($link, int $pagesize, bool $iscritical = false, string $cookie = ""): void
+{
+    error_clear_last();
+    $safeResult = \ldap_control_paged_result($link, $pagesize, $iscritical, $cookie);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @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;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_delete(\LDAP\Connection $ldap, string $dn, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_delete($ldap, $dn, $controls);
+    } else {
+        $safeResult = \ldap_delete($ldap, $dn);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $dn
+ * @return string
+ * @throws LdapException
+ *
+ */
+function ldap_dn2ufn(string $dn): string
+{
+    error_clear_last();
+    $safeResult = \ldap_dn2ufn($dn);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $user
+ * @param string $old_password
+ * @param string $new_password
+ * @param array|null $controls
+ * @return bool|string
+ * @throws LdapException
+ *
+ */
+function ldap_exop_passwd(\LDAP\Connection $ldap, string $user = "", string $old_password = "", string $new_password = "", ?array &$controls = null)
+{
+    error_clear_last();
+    $safeResult = \ldap_exop_passwd($ldap, $user, $old_password, $new_password, $controls);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @return bool|string
+ * @throws LdapException
+ *
+ */
+function ldap_exop_whoami(\LDAP\Connection $ldap)
+{
+    error_clear_last();
+    $safeResult = \ldap_exop_whoami($ldap);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @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 bool|resource
+ * @throws LdapException
+ *
+ */
+function ldap_exop(\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($ldap, $request_oid, $request_data, $controls, $response_data, $response_oid);
+    } elseif ($response_data !== null) {
+        $safeResult = \ldap_exop($ldap, $request_oid, $request_data, $controls, $response_data);
+    } elseif ($controls !== null) {
+        $safeResult = \ldap_exop($ldap, $request_oid, $request_data, $controls);
+    } elseif ($request_data !== null) {
+        $safeResult = \ldap_exop($ldap, $request_oid, $request_data);
+    } else {
+        $safeResult = \ldap_exop($ldap, $request_oid);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $dn
+ * @param int $with_attrib
+ * @return array
+ * @throws LdapException
+ *
+ */
+function ldap_explode_dn(string $dn, int $with_attrib): array
+{
+    error_clear_last();
+    $safeResult = \ldap_explode_dn($dn, $with_attrib);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @return string
+ * @throws LdapException
+ *
+ */
+function ldap_first_attribute(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry): string
+{
+    error_clear_last();
+    $safeResult = \ldap_first_attribute($ldap, $entry);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\Result $result
+ * @return \LDAP\ResultEntry
+ * @throws LdapException
+ *
+ */
+function ldap_first_entry(\LDAP\Connection $ldap, \LDAP\Result $result): \LDAP\ResultEntry
+{
+    error_clear_last();
+    $safeResult = \ldap_first_entry($ldap, $result);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Result $result
+ * @throws LdapException
+ *
+ */
+function ldap_free_result(\LDAP\Result $result): void
+{
+    error_clear_last();
+    $safeResult = \ldap_free_result($result);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @return array
+ *
+ */
+function ldap_get_attributes(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry): array
+{
+    error_clear_last();
+    $safeResult = \ldap_get_attributes($ldap, $entry);
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @return string
+ * @throws LdapException
+ *
+ */
+function ldap_get_dn(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry): string
+{
+    error_clear_last();
+    $safeResult = \ldap_get_dn($ldap, $entry);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\Result $result
+ * @return array
+ * @throws LdapException
+ *
+ */
+function ldap_get_entries(\LDAP\Connection $ldap, \LDAP\Result $result): array
+{
+    error_clear_last();
+    $safeResult = \ldap_get_entries($ldap, $result);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection|null $ldap
+ * @param int $option
+ * @param mixed $value
+ * @throws LdapException
+ *
+ */
+function ldap_get_option(?\LDAP\Connection $ldap, int $option, &$value = null): void
+{
+    error_clear_last();
+    $safeResult = \ldap_get_option($ldap, $option, $value);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @param string $attribute
+ * @return array
+ * @throws LdapException
+ *
+ */
+function ldap_get_values_len(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry, string $attribute): array
+{
+    error_clear_last();
+    $safeResult = \ldap_get_values_len($ldap, $entry, $attribute);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @param string $attribute
+ * @return array
+ * @throws LdapException
+ *
+ */
+function ldap_get_values(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry, string $attribute): array
+{
+    error_clear_last();
+    $safeResult = \ldap_get_values($ldap, $entry, $attribute);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array $entry
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_mod_add(\LDAP\Connection $ldap, string $dn, array $entry, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_mod_add($ldap, $dn, $entry, $controls);
+    } else {
+        $safeResult = \ldap_mod_add($ldap, $dn, $entry);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array $entry
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_mod_del(\LDAP\Connection $ldap, string $dn, array $entry, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_mod_del($ldap, $dn, $entry, $controls);
+    } else {
+        $safeResult = \ldap_mod_del($ldap, $dn, $entry);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array $entry
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_mod_replace(\LDAP\Connection $ldap, string $dn, array $entry, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_mod_replace($ldap, $dn, $entry, $controls);
+    } else {
+        $safeResult = \ldap_mod_replace($ldap, $dn, $entry);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param array $modifications_info
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_modify_batch(\LDAP\Connection $ldap, string $dn, array $modifications_info, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_modify_batch($ldap, $dn, $modifications_info, $controls);
+    } else {
+        $safeResult = \ldap_modify_batch($ldap, $dn, $modifications_info);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\ResultEntry $entry
+ * @return string
+ * @throws LdapException
+ *
+ */
+function ldap_next_attribute(\LDAP\Connection $ldap, \LDAP\ResultEntry $entry): string
+{
+    error_clear_last();
+    $safeResult = \ldap_next_attribute($ldap, $entry);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\Result $result
+ * @param null|string $response_data
+ * @param null|string $response_oid
+ * @throws LdapException
+ *
+ */
+function ldap_parse_exop(\LDAP\Connection $ldap, \LDAP\Result $result, ?string &$response_data = null, ?string &$response_oid = null): void
+{
+    error_clear_last();
+    $safeResult = \ldap_parse_exop($ldap, $result, $response_data, $response_oid);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param \LDAP\Result $result
+ * @param int|null $error_code
+ * @param null|string $matched_dn
+ * @param null|string $error_message
+ * @param array|null $referrals
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_parse_result(\LDAP\Connection $ldap, \LDAP\Result $result, ?int &$error_code, ?string &$matched_dn = null, ?string &$error_message = null, ?array &$referrals = null, ?array &$controls = null): void
+{
+    error_clear_last();
+    $safeResult = \ldap_parse_result($ldap, $result, $error_code, $matched_dn, $error_message, $referrals, $controls);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param string $dn
+ * @param string $new_rdn
+ * @param string $new_parent
+ * @param bool $delete_old_rdn
+ * @param array|null $controls
+ * @throws LdapException
+ *
+ */
+function ldap_rename(\LDAP\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, ?array $controls = null): void
+{
+    error_clear_last();
+    if ($controls !== null) {
+        $safeResult = \ldap_rename($ldap, $dn, $new_rdn, $new_parent, $delete_old_rdn, $controls);
+    } else {
+        $safeResult = \ldap_rename($ldap, $dn, $new_rdn, $new_parent, $delete_old_rdn);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @param null|string $dn
+ * @param null|string $password
+ * @param null|string $mech
+ * @param null|string $realm
+ * @param null|string $authc_id
+ * @param null|string $authz_id
+ * @param null|string $props
+ * @throws LdapException
+ *
+ */
+function ldap_sasl_bind(\LDAP\Connection $ldap, ?string $dn = null, ?string $password = null, ?string $mech = null, ?string $realm = null, ?string $authc_id = null, ?string $authz_id = null, ?string $props = null): void
+{
+    error_clear_last();
+    if ($props !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password, $mech, $realm, $authc_id, $authz_id, $props);
+    } elseif ($authz_id !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password, $mech, $realm, $authc_id, $authz_id);
+    } elseif ($authc_id !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password, $mech, $realm, $authc_id);
+    } elseif ($realm !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password, $mech, $realm);
+    } elseif ($mech !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password, $mech);
+    } elseif ($password !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn, $password);
+    } elseif ($dn !== null) {
+        $safeResult = \ldap_sasl_bind($ldap, $dn);
+    } else {
+        $safeResult = \ldap_sasl_bind($ldap);
+    }
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param null|resource $ldap
+ * @param int $option
+ * @param mixed $value
+ * @throws LdapException
+ *
+ */
+function ldap_set_option($ldap, int $option, $value): void
+{
+    error_clear_last();
+    $safeResult = \ldap_set_option($ldap, $option, $value);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param \LDAP\Connection $ldap
+ * @throws LdapException
+ *
+ */
+function ldap_unbind(\LDAP\Connection $ldap): void
+{
+    error_clear_last();
+    $safeResult = \ldap_unbind($ldap);
+    if ($safeResult === false) {
+        throw LdapException::createFromPhpError();
+    }
+}

vendor/thecodingmachine/safe/generated/8.6/pcntl.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\PcntlException;
+
+/**
+ * @param int|null $process_id
+ * @return array
+ * @throws PcntlException
+ *
+ */
+function pcntl_getcpuaffinity(?int $process_id = null): array
+{
+    error_clear_last();
+    if ($process_id !== null) {
+        $safeResult = \pcntl_getcpuaffinity($process_id);
+    } else {
+        $safeResult = \pcntl_getcpuaffinity();
+    }
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int|null $process_id
+ * @param int $mode
+ * @return int
+ * @throws PcntlException
+ *
+ */
+function pcntl_getpriority(?int $process_id = null, int $mode = PRIO_PROCESS): int
+{
+    error_clear_last();
+    if ($mode !== PRIO_PROCESS) {
+        $safeResult = \pcntl_getpriority($process_id, $mode);
+    } elseif ($process_id !== null) {
+        $safeResult = \pcntl_getpriority($process_id);
+    } else {
+        $safeResult = \pcntl_getpriority();
+    }
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int|null $process_id
+ * @param array $cpu_ids
+ * @throws PcntlException
+ *
+ */
+function pcntl_setcpuaffinity(?int $process_id = null, array $cpu_ids = []): void
+{
+    error_clear_last();
+    if ($cpu_ids !== []) {
+        $safeResult = \pcntl_setcpuaffinity($process_id, $cpu_ids);
+    } elseif ($process_id !== null) {
+        $safeResult = \pcntl_setcpuaffinity($process_id);
+    } else {
+        $safeResult = \pcntl_setcpuaffinity();
+    }
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param int $priority
+ * @param int|null $process_id
+ * @param int $mode
+ * @throws PcntlException
+ *
+ */
+function pcntl_setpriority(int $priority, ?int $process_id = null, int $mode = PRIO_PROCESS): void
+{
+    error_clear_last();
+    if ($mode !== PRIO_PROCESS) {
+        $safeResult = \pcntl_setpriority($priority, $process_id, $mode);
+    } elseif ($process_id !== null) {
+        $safeResult = \pcntl_setpriority($priority, $process_id);
+    } else {
+        $safeResult = \pcntl_setpriority($priority);
+    }
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @throws PcntlException
+ *
+ */
+function pcntl_signal_dispatch(): void
+{
+    error_clear_last();
+    $safeResult = \pcntl_signal_dispatch();
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param int $signal
+ * @param callable|int $handler
+ * @param bool $restart_syscalls
+ * @throws PcntlException
+ *
+ */
+function pcntl_signal(int $signal, $handler, bool $restart_syscalls = true): void
+{
+    error_clear_last();
+    $safeResult = \pcntl_signal($signal, $handler, $restart_syscalls);
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param int $mode
+ * @param array $signals
+ * @param array|null $old_signals
+ * @throws PcntlException
+ *
+ */
+function pcntl_sigprocmask(int $mode, array $signals, ?array &$old_signals = null): void
+{
+    error_clear_last();
+    $safeResult = \pcntl_sigprocmask($mode, $signals, $old_signals);
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param array $signals
+ * @param array|null $info
+ * @param int $seconds
+ * @param int $nanoseconds
+ * @return int
+ * @throws PcntlException
+ *
+ */
+function pcntl_sigtimedwait(array $signals, ?array &$info = [], int $seconds = 0, int $nanoseconds = 0): int
+{
+    error_clear_last();
+    $safeResult = \pcntl_sigtimedwait($signals, $info, $seconds, $nanoseconds);
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param array $signals
+ * @param array|null $info
+ * @return int
+ * @throws PcntlException
+ *
+ */
+function pcntl_sigwaitinfo(array $signals, ?array &$info = []): int
+{
+    error_clear_last();
+    $safeResult = \pcntl_sigwaitinfo($signals, $info);
+    if ($safeResult === false) {
+        throw PcntlException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.6/yaml.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\YamlException;
+
+/**
+ * @param string $filename
+ * @param int $pos
+ * @param int|null $ndocs
+ * @param array|null $callbacks
+ * @return mixed
+ *
+ */
+function yaml_parse_file(string $filename, int $pos = 0, ?int &$ndocs = null, ?array $callbacks = null)
+{
+    error_clear_last();
+    if ($callbacks !== null) {
+        $safeResult = \yaml_parse_file($filename, $pos, $ndocs, $callbacks);
+    } else {
+        $safeResult = \yaml_parse_file($filename, $pos, $ndocs);
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $url
+ * @param int $pos
+ * @param int|null $ndocs
+ * @param array|null $callbacks
+ * @return mixed
+ * @throws YamlException
+ *
+ */
+function yaml_parse_url(string $url, int $pos = 0, ?int &$ndocs = null, ?array $callbacks = null)
+{
+    error_clear_last();
+    if ($callbacks !== null) {
+        $safeResult = \yaml_parse_url($url, $pos, $ndocs, $callbacks);
+    } else {
+        $safeResult = \yaml_parse_url($url, $pos, $ndocs);
+    }
+    if ($safeResult === false) {
+        throw YamlException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $input
+ * @param int $pos
+ * @param int|null $ndocs
+ * @param array|null $callbacks
+ * @return mixed
+ * @throws YamlException
+ *
+ */
+function yaml_parse(string $input, int $pos = 0, ?int &$ndocs = null, ?array $callbacks = null)
+{
+    error_clear_last();
+    if ($callbacks !== null) {
+        $safeResult = \yaml_parse($input, $pos, $ndocs, $callbacks);
+    } else {
+        $safeResult = \yaml_parse($input, $pos, $ndocs);
+    }
+    if ($safeResult === false) {
+        throw YamlException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.6/zlib.php

@@ -0,0 +1,415 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ZlibException;
+
+/**
+ * @param \DeflateContext $context
+ * @param string $data
+ * @param int $flush_mode
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function deflate_add(\DeflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string
+{
+    error_clear_last();
+    $safeResult = \deflate_add($context, $data, $flush_mode);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $encoding
+ * @param array $options
+ * @return \DeflateContext
+ * @throws ZlibException
+ *
+ */
+function deflate_init(int $encoding, array $options = []): \DeflateContext
+{
+    error_clear_last();
+    $safeResult = \deflate_init($encoding, $options);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @throws ZlibException
+ *
+ */
+function gzclose($stream): void
+{
+    error_clear_last();
+    $safeResult = \gzclose($stream);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param string $data
+ * @param int $level
+ * @param int $encoding
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzcompress(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_DEFLATE): string
+{
+    error_clear_last();
+    $safeResult = \gzcompress($data, $level, $encoding);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $max_length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzdecode(string $data, int $max_length = 0): string
+{
+    error_clear_last();
+    $safeResult = \gzdecode($data, $max_length);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $level
+ * @param int $encoding
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzdeflate(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_RAW): string
+{
+    error_clear_last();
+    $safeResult = \gzdeflate($data, $level, $encoding);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $level
+ * @param int $encoding
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzencode(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_GZIP): string
+{
+    error_clear_last();
+    $safeResult = \gzencode($data, $level, $encoding);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @param  $use_include_path
+ * @return list
+ * @throws ZlibException
+ *
+ */
+function gzfile(string $filename, $use_include_path = false): array
+{
+    error_clear_last();
+    $safeResult = \gzfile($filename, $use_include_path);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param int|null $length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzgets($stream, ?int $length = null): string
+{
+    error_clear_last();
+    if ($length !== null) {
+        $safeResult = \gzgets($stream, $length);
+    } else {
+        $safeResult = \gzgets($stream);
+    }
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $max_length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzinflate(string $data, int $max_length = 0): string
+{
+    error_clear_last();
+    $safeResult = \gzinflate($data, $max_length);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @param string $mode
+ * @param  $use_include_path
+ * @return resource
+ * @throws ZlibException
+ *
+ */
+function gzopen(string $filename, string $mode, $use_include_path = false)
+{
+    error_clear_last();
+    $safeResult = \gzopen($filename, $mode, $use_include_path);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @return false|int
+ *
+ */
+function gzpassthru($stream)
+{
+    error_clear_last();
+    $safeResult = \gzpassthru($stream);
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param int $length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzread($stream, int $length): string
+{
+    error_clear_last();
+    $safeResult = \gzread($stream, $length);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @throws ZlibException
+ *
+ */
+function gzrewind($stream): void
+{
+    error_clear_last();
+    $safeResult = \gzrewind($stream);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+}
+
+
+/**
+ * @param resource $stream
+ * @return int
+ * @throws ZlibException
+ *
+ */
+function gztell($stream): int
+{
+    error_clear_last();
+    $safeResult = \gztell($stream);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $max_length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function gzuncompress(string $data, int $max_length = 0): string
+{
+    error_clear_last();
+    $safeResult = \gzuncompress($data, $max_length);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param resource $stream
+ * @param string $data
+ * @param int|null $length
+ * @return int
+ * @throws ZlibException
+ *
+ */
+function gzwrite($stream, string $data, ?int $length = null): int
+{
+    error_clear_last();
+    if ($length !== null) {
+        $safeResult = \gzwrite($stream, $data, $length);
+    } else {
+        $safeResult = \gzwrite($stream, $data);
+    }
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \InflateContext $context
+ * @return int
+ * @throws ZlibException
+ *
+ */
+function inflate_get_read_len(\InflateContext $context): int
+{
+    error_clear_last();
+    $safeResult = \inflate_get_read_len($context);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param \InflateContext $context
+ * @return false|int
+ *
+ */
+function inflate_get_status(\InflateContext $context)
+{
+    error_clear_last();
+    $safeResult = \inflate_get_status($context);
+    return $safeResult;
+}
+
+
+/**
+ * @param \InflateContext $context
+ * @param string $data
+ * @param int $flush_mode
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function inflate_add(\InflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string
+{
+    error_clear_last();
+    $safeResult = \inflate_add($context, $data, $flush_mode);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param int $encoding
+ * @param array $options
+ * @return \InflateContext
+ * @throws ZlibException
+ *
+ */
+function inflate_init(int $encoding, array $options = []): \InflateContext
+{
+    error_clear_last();
+    $safeResult = \inflate_init($encoding, $options);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $filename
+ * @param  $use_include_path
+ * @return 0|positive-int
+ * @throws ZlibException
+ *
+ */
+function readgzfile(string $filename, $use_include_path = false): int
+{
+    error_clear_last();
+    $safeResult = \readgzfile($filename, $use_include_path);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * @param string $data
+ * @param int $max_length
+ * @return string
+ * @throws ZlibException
+ *
+ */
+function zlib_decode(string $data, int $max_length = 0): string
+{
+    error_clear_last();
+    $safeResult = \zlib_decode($data, $max_length);
+    if ($safeResult === false) {
+        throw ZlibException::createFromPhpError();
+    }
+    return $safeResult;
+}