harga pada beranda terhubung ke manage plans di dashboard admin

vendor/thecodingmachine/safe/generated/8.2/apache.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ApacheException;
+
+/**
+ * Fetch the Apache version.
+ *
+ * @return string Returns the Apache version on success.
+ * @throws ApacheException
+ *
+ */
+function apache_get_version(): string
+{
+    error_clear_last();
+    $safeResult = \apache_get_version();
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Retrieve an Apache environment variable specified by
+ * variable.
+ *
+ * @param string $variable The Apache environment variable
+ * @param bool $walk_to_top Whether to get the top-level variable available to all Apache layers.
+ * @return string The value of the Apache environment variable on success
+ * @throws ApacheException
+ *
+ */
+function apache_getenv(string $variable, bool $walk_to_top = false): string
+{
+    error_clear_last();
+    $safeResult = \apache_getenv($variable, $walk_to_top);
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * This performs a partial request for a URI.  It goes just far
+ * enough to obtain all the important information about the given
+ * resource.
+ *
+ * @param string $filename The filename (URI) that's being requested.
+ * @return object An object of related URI information. The properties of
+ * this object are:
+ *
+ *
+ * status
+ * the_request
+ * status_line
+ * method
+ * content_type
+ * handler
+ * uri
+ * filename
+ * path_info
+ * args
+ * boundary
+ * no_cache
+ * no_local_copy
+ * allowed
+ * send_bodyct
+ * bytes_sent
+ * byterange
+ * clength
+ * unparsed_uri
+ * mtime
+ * request_time
+ *
+ *
+ * Returns FALSE on failure.
+ * @throws ApacheException
+ *
+ */
+function apache_lookup_uri(string $filename): object
+{
+    error_clear_last();
+    $safeResult = \apache_lookup_uri($filename);
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Fetches all HTTP request headers from the current request. Works in the
+ * Apache, FastCGI, CLI, and FPM webservers.
+ *
+ * @return array An associative array of all the HTTP headers in the current request.
+ * @throws ApacheException
+ *
+ */
+function apache_request_headers(): array
+{
+    error_clear_last();
+    $safeResult = \apache_request_headers();
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Fetch all HTTP response headers.  Works in the
+ * Apache, FastCGI, CLI, and FPM webservers.
+ *
+ * @return array An array of all Apache response headers on success.
+ * @throws ApacheException
+ *
+ */
+function apache_response_headers(): array
+{
+    error_clear_last();
+    $safeResult = \apache_response_headers();
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * apache_setenv sets the value of the Apache
+ * environment variable specified by
+ * variable.
+ *
+ * @param string $variable The environment variable that's being set.
+ * @param string $value The new variable value.
+ * @param bool $walk_to_top Whether to set the top-level variable available to all Apache layers.
+ * @throws ApacheException
+ *
+ */
+function apache_setenv(string $variable, string $value, bool $walk_to_top = false): void
+{
+    error_clear_last();
+    $safeResult = \apache_setenv($variable, $value, $walk_to_top);
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Fetches all HTTP headers from the current request.
+ *
+ * This function is an alias for apache_request_headers.
+ * Please read the apache_request_headers
+ * documentation for more information on how this function works.
+ *
+ * @return array An associative array of all the HTTP headers in the current request.
+ * @throws ApacheException
+ *
+ */
+function getallheaders(): array
+{
+    error_clear_last();
+    $safeResult = \getallheaders();
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * virtual is an Apache-specific function which
+ * is similar to &lt;!--#include virtual...--&gt; in
+ * mod_include.
+ * It performs an Apache sub-request.  It is useful for including
+ * CGI scripts or .shtml files, or anything else that you would
+ * parse through Apache. Note that for a CGI script, the script
+ * must generate valid CGI headers.  At the minimum that means it
+ * must generate a Content-Type header.
+ *
+ * To run the sub-request, all buffers are terminated and flushed to the
+ * browser, pending headers are sent too.
+ *
+ * @param string $uri The file that the virtual command will be performed on.
+ * @throws ApacheException
+ *
+ */
+function virtual(string $uri): void
+{
+    error_clear_last();
+    $safeResult = \virtual($uri);
+    if ($safeResult === false) {
+        throw ApacheException::createFromPhpError();
+    }
+}

vendor/thecodingmachine/safe/generated/8.2/apcu.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ApcuException;
+
+/**
+ * Retrieves cached information and meta-data from APC's data store.
+ *
+ * @param bool $limited If limited is TRUE, the
+ * return value will exclude the individual list of cache entries.  This
+ * is useful when trying to optimize calls for statistics gathering.
+ * @return array Array of cached data (and meta-data)
+ * @throws ApcuException
+ *
+ */
+function apcu_cache_info(bool $limited = false): array
+{
+    error_clear_last();
+    $safeResult = \apcu_cache_info($limited);
+    if ($safeResult === false) {
+        throw ApcuException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * apcu_cas updates an already existing integer value if the
+ * old parameter matches the currently stored value
+ * with the value of the new parameter.
+ *
+ * @param string $key The key of the value being updated.
+ * @param int $old The old value (the value currently stored).
+ * @param int $new The new value to update to.
+ * @throws ApcuException
+ *
+ */
+function apcu_cas(string $key, int $old, int $new): void
+{
+    error_clear_last();
+    $safeResult = \apcu_cas($key, $old, $new);
+    if ($safeResult === false) {
+        throw ApcuException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Decreases a stored integer value.
+ *
+ * @param string $key The key of the value being decreased.
+ * @param int $step The step, or value to decrease.
+ * @param bool|null $success Optionally pass the success or fail boolean value to
+ * this referenced variable.
+ * @param int $ttl TTL to use if the operation inserts a new value (rather than decrementing an existing one).
+ * @return int Returns the current value of key's value on success
+ * @throws ApcuException
+ *
+ */
+function apcu_dec(string $key, int $step = 1, ?bool &$success = null, int $ttl = 0): int
+{
+    error_clear_last();
+    $safeResult = \apcu_dec($key, $step, $success, $ttl);
+    if ($safeResult === false) {
+        throw ApcuException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Increases a stored number.
+ *
+ * @param string $key The key of the value being increased.
+ * @param int $step The step, or value to increase.
+ * @param bool|null $success Optionally pass the success or fail boolean value to
+ * this referenced variable.
+ * @param int $ttl TTL to use if the operation inserts a new value (rather than incrementing an existing one).
+ * @return int Returns the current value of key's value on success
+ * @throws ApcuException
+ *
+ */
+function apcu_inc(string $key, int $step = 1, ?bool &$success = null, int $ttl = 0): int
+{
+    error_clear_last();
+    $safeResult = \apcu_inc($key, $step, $success, $ttl);
+    if ($safeResult === false) {
+        throw ApcuException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Retrieves APCu Shared Memory Allocation information.
+ *
+ * @param bool $limited When set to FALSE (default) apcu_sma_info will
+ * return a detailed information about each segment.
+ * @return array Array of Shared Memory Allocation data; FALSE on failure.
+ * @throws ApcuException
+ *
+ */
+function apcu_sma_info(bool $limited = false): array
+{
+    error_clear_last();
+    $safeResult = \apcu_sma_info($limited);
+    if ($safeResult === false) {
+        throw ApcuException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/bzip2.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\Bzip2Exception;
+
+/**
+ * Closes the given bzip2 file pointer.
+ *
+ * @param resource $bz The file pointer. It must be valid and must point to a file
+ * successfully opened by bzopen.
+ * @throws Bzip2Exception
+ *
+ */
+function bzclose($bz): void
+{
+    error_clear_last();
+    $safeResult = \bzclose($bz);
+    if ($safeResult === false) {
+        throw Bzip2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * This function is supposed to force a write of all buffered bzip2 data for the file pointer
+ * bz,
+ * but is implemented as null function in libbz2, and as such does nothing.
+ *
+ * @param resource $bz The file pointer. It must be valid and must point to a file
+ * successfully opened by bzopen.
+ * @throws Bzip2Exception
+ *
+ */
+function bzflush($bz): void
+{
+    error_clear_last();
+    $safeResult = \bzflush($bz);
+    if ($safeResult === false) {
+        throw Bzip2Exception::createFromPhpError();
+    }
+}
+
+
+/**
+ * bzopen opens a bzip2 (.bz2) file for reading or
+ * writing.
+ *
+ * @param resource|string $file The name of the file to open, or an existing stream resource.
+ * @param string $mode The modes 'r' (read), and 'w' (write) are supported.
+ * Everything else will cause bzopen to return FALSE.
+ * @return resource If the open fails, bzopen returns FALSE, otherwise
+ * it returns a pointer to the newly opened file.
+ * @throws Bzip2Exception
+ *
+ */
+function bzopen($file, string $mode)
+{
+    error_clear_last();
+    $safeResult = \bzopen($file, $mode);
+    if ($safeResult === false) {
+        throw Bzip2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * bzread reads from the given bzip2 file pointer.
+ *
+ * Reading stops when length (uncompressed) bytes have
+ * been read or EOF is reached, whichever comes first.
+ *
+ * @param resource $bz The file pointer. It must be valid and must point to a file
+ * successfully opened by bzopen.
+ * @param int $length If not specified, bzread will read 1024
+ * (uncompressed) bytes at a time. A maximum of 8192
+ * uncompressed bytes will be read at a time.
+ * @return string Returns the uncompressed data.
+ * @throws Bzip2Exception
+ *
+ */
+function bzread($bz, int $length = 1024): string
+{
+    error_clear_last();
+    $safeResult = \bzread($bz, $length);
+    if ($safeResult === false) {
+        throw Bzip2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * bzwrite writes a string into the given bzip2 file
+ * stream.
+ *
+ * @param resource $bz The file pointer. It must be valid and must point to a file
+ * successfully opened by bzopen.
+ * @param string $data The written data.
+ * @param int|null $length If supplied, writing will stop after length
+ * (uncompressed) bytes have been written or the end of
+ * data is reached, whichever comes first.
+ * @return int Returns the number of bytes written.
+ * @throws Bzip2Exception
+ *
+ */
+function bzwrite($bz, string $data, ?int $length = null): int
+{
+    error_clear_last();
+    if ($length !== null) {
+        $safeResult = \bzwrite($bz, $data, $length);
+    } else {
+        $safeResult = \bzwrite($bz, $data);
+    }
+    if ($safeResult === false) {
+        throw Bzip2Exception::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/calendar.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\CalendarException;
+
+/**
+ * Return the Julian Day for a Unix timestamp
+ * (seconds since 1.1.1970), or for the current day if no
+ * timestamp is given. Either way, the time is regarded
+ * as local time (not UTC).
+ *
+ * @param int|null $timestamp A unix timestamp to convert.
+ * @return int A julian day number as integer.
+ * @throws CalendarException
+ *
+ */
+function unixtojd(?int $timestamp = null): int
+{
+    error_clear_last();
+    if ($timestamp !== null) {
+        $safeResult = \unixtojd($timestamp);
+    } else {
+        $safeResult = \unixtojd();
+    }
+    if ($safeResult === false) {
+        throw CalendarException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/classobj.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ClassobjException;
+
+/**
+ * Creates an alias named alias
+ * based on the user defined class class.
+ * The aliased class is exactly the same as the original class.
+ *
+ * @param string $class The original class.
+ * @param string $alias The alias name for the class.
+ * @param bool $autoload Whether to autoload if the original class is not found.
+ * @throws ClassobjException
+ *
+ */
+function class_alias(string $class, string $alias, bool $autoload = true): void
+{
+    error_clear_last();
+    $safeResult = \class_alias($class, $alias, $autoload);
+    if ($safeResult === false) {
+        throw ClassobjException::createFromPhpError();
+    }
+}

vendor/thecodingmachine/safe/generated/8.2/com.php

@@ -0,0 +1,196 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\ComException;
+
+/**
+ * Generates a Globally Unique Identifier (GUID).
+ *
+ * A GUID is generated in the same way as DCE UUID's, except that the
+ * Microsoft convention is to enclose a GUID in curly braces.
+ *
+ * @return string Returns the GUID as a string.
+ * @throws ComException
+ *
+ */
+function com_create_guid(): string
+{
+    error_clear_last();
+    $safeResult = \com_create_guid();
+    if ($safeResult === false) {
+        throw ComException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Instructs COM to sink events generated by
+ * variant into the PHP object
+ * sink_object.
+ *
+ * Be careful how you use this feature; if you are doing something similar
+ * to the example below, then it doesn't really make sense to run it in a
+ * web server context.
+ *
+ * @param object $variant
+ * @param object $sink_object sink_object should be an instance of a class with
+ * methods named after those of the desired dispinterface; you may use
+ * com_print_typeinfo to help generate a template class
+ * for this purpose.
+ * @param mixed $sink_interface PHP will attempt to use the default dispinterface type specified by
+ * the typelibrary associated with variant, but
+ * you may override this choice by setting
+ * sink_interface to the name of the dispinterface
+ * that you want to use.
+ * @throws ComException
+ *
+ */
+function com_event_sink(object $variant, object $sink_object, $sink_interface = null): void
+{
+    error_clear_last();
+    if ($sink_interface !== null) {
+        $safeResult = \com_event_sink($variant, $sink_object, $sink_interface);
+    } else {
+        $safeResult = \com_event_sink($variant, $sink_object);
+    }
+    if ($safeResult === false) {
+        throw ComException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Loads a type-library and registers its constants in the engine, as though
+ * they were defined using define.
+ *
+ * Note that it is much more efficient to use the com.typelib-file php.ini setting to pre-load and
+ * register the constants, although not so flexible.
+ *
+ * If com.autoregister-typelib is turned on, then
+ * PHP will attempt to automatically register the constants associated with a
+ * COM object when you instantiate it.  This depends on the interfaces
+ * provided by the COM object itself, and may not always be possible.
+ *
+ * @param string $typelib typelib can be one of the following:
+ *
+ *
+ *
+ * The filename of a .tlb file or the executable module
+ * that contains the type library.
+ *
+ *
+ *
+ *
+ * The type library GUID, followed by its version number, for example
+ * {00000200-0000-0010-8000-00AA006D2EA4},2,0.
+ *
+ *
+ *
+ *
+ * The type library name, e.g. Microsoft OLE DB ActiveX Data
+ * Objects 1.0 Library.
+ *
+ *
+ *
+ * PHP will attempt to resolve the type library in this order, as the
+ * process gets more and more expensive as you progress down the list;
+ * searching for the type library by name is handled by physically
+ * enumerating the registry until we find a match.
+ *
+ * The filename of a .tlb file or the executable module
+ * that contains the type library.
+ *
+ * The type library GUID, followed by its version number, for example
+ * {00000200-0000-0010-8000-00AA006D2EA4},2,0.
+ *
+ * The type library name, e.g. Microsoft OLE DB ActiveX Data
+ * Objects 1.0 Library.
+ * @param bool $case_insensitive The case_insensitive behaves inversely to
+ * the parameter $case_insensitive in the define
+ * function.
+ * @throws ComException
+ *
+ */
+function com_load_typelib(string $typelib, bool $case_insensitive = true): void
+{
+    error_clear_last();
+    $safeResult = \com_load_typelib($typelib, $case_insensitive);
+    if ($safeResult === false) {
+        throw ComException::createFromPhpError();
+    }
+}
+
+
+/**
+ * The purpose of this function is to help generate a skeleton class for use
+ * as an event sink.  You may also use it to generate a dump of any COM
+ * object, provided that it supports enough of the introspection interfaces,
+ * and that you know the name of the interface you want to display.
+ *
+ * @param object $variant variant should be either an instance of a COM
+ * object, or be the name of a typelibrary (which will be resolved according
+ * to the rules set out in com_load_typelib).
+ * @param null|string $dispatch_interface The name of an IDispatch descendant interface that you want to display.
+ * @param bool $display_sink If set to TRUE, the corresponding sink interface will be displayed
+ * instead.
+ * @throws ComException
+ *
+ */
+function com_print_typeinfo(object $variant, ?string $dispatch_interface = null, bool $display_sink = false): void
+{
+    error_clear_last();
+    if ($display_sink !== false) {
+        $safeResult = \com_print_typeinfo($variant, $dispatch_interface, $display_sink);
+    } elseif ($dispatch_interface !== null) {
+        $safeResult = \com_print_typeinfo($variant, $dispatch_interface);
+    } else {
+        $safeResult = \com_print_typeinfo($variant);
+    }
+    if ($safeResult === false) {
+        throw ComException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Converts variant from a VT_DATE
+ * (or similar) value into a Unix timestamp.  This allows easier
+ * interopability between the Unix-ish parts of PHP and COM.
+ *
+ * @param object $variant The variant.
+ * @return int Returns a unix timestamp.
+ * @throws ComException
+ *
+ */
+function variant_date_to_timestamp(object $variant): int
+{
+    error_clear_last();
+    $safeResult = \variant_date_to_timestamp($variant);
+    if ($safeResult === null) {
+        throw ComException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Returns the value of value rounded to
+ * decimals decimal places.
+ *
+ * @param mixed $value The variant.
+ * @param int $decimals Number of decimal places.
+ * @return mixed Returns the rounded value.
+ * @throws ComException
+ *
+ */
+function variant_round($value, int $decimals)
+{
+    error_clear_last();
+    $safeResult = \variant_round($value, $decimals);
+    if ($safeResult === null) {
+        throw ComException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/dir.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\DirException;
+
+/**
+ * Changes PHP's current directory to
+ * directory.
+ *
+ * @param string $directory The new current directory
+ * @throws DirException
+ *
+ */
+function chdir(string $directory): void
+{
+    error_clear_last();
+    $safeResult = \chdir($directory);
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Changes the root directory of the current process to
+ * directory, and changes the current
+ * working directory to "/".
+ *
+ * This function is only available to GNU and BSD systems, and
+ * only when using the CLI, CGI or Embed SAPI. Also, this function
+ * requires root privileges.
+ *
+ * Calling this function does not change the values of the __DIR__
+ * and __FILE__ magic constants.
+ *
+ * @param string $directory The path to change the root directory to.
+ * @throws DirException
+ *
+ */
+function chroot(string $directory): void
+{
+    error_clear_last();
+    $safeResult = \chroot($directory);
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+}
+
+
+/**
+ * A pseudo-object-oriented mechanism for reading a directory.  The
+ * given directory is opened.
+ *
+ * @param string $directory Directory to open
+ * @param null|resource $context A context stream
+ * resource.
+ * @return \Directory Returns an instance of Directory, or FALSE in case of error.
+ * @throws DirException
+ *
+ */
+function dir(string $directory, $context = null): \Directory
+{
+    error_clear_last();
+    if ($context !== null) {
+        $safeResult = \dir($directory, $context);
+    } else {
+        $safeResult = \dir($directory);
+    }
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Gets the current working directory.
+ *
+ * @return non-empty-string Returns the current working directory on success.
+ *
+ * On some Unix variants, getcwd will return
+ * FALSE if any one of the parent directories does not have the
+ * readable or search mode set, even if the current directory
+ * does. See chmod for more information on
+ * modes and permissions.
+ * @throws DirException
+ *
+ */
+function getcwd(): string
+{
+    error_clear_last();
+    $safeResult = \getcwd();
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Opens up a directory handle to be used in subsequent
+ * closedir, readdir, and
+ * rewinddir calls.
+ *
+ * @param string $directory The directory path that is to be opened
+ * @param null|resource $context For a description of the context parameter,
+ * refer to the streams section of
+ * the manual.
+ * @return resource Returns a directory handle resource on success
+ * @throws DirException
+ *
+ */
+function opendir(string $directory, $context = null)
+{
+    error_clear_last();
+    if ($context !== null) {
+        $safeResult = \opendir($directory, $context);
+    } else {
+        $safeResult = \opendir($directory);
+    }
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Returns an array of files and directories from the
+ * directory.
+ *
+ * @param string $directory The directory that will be scanned.
+ * @param SCANDIR_SORT_ASCENDING|SCANDIR_SORT_DESCENDING|SCANDIR_SORT_NONE $sorting_order By default, the sorted order is alphabetical in ascending order.  If
+ * the optional sorting_order is set to
+ * SCANDIR_SORT_DESCENDING, then the sort order is
+ * alphabetical in descending order. If it is set to
+ * SCANDIR_SORT_NONE then the result is unsorted.
+ * @param null|resource $context For a description of the context parameter,
+ * refer to the streams section of
+ * the manual.
+ * @return list Returns an array of filenames on success. If directory is not a directory, then
+ * boolean FALSE is returned, and an error of level
+ * E_WARNING is generated.
+ * @throws DirException
+ *
+ */
+function scandir(string $directory, int $sorting_order = SCANDIR_SORT_ASCENDING, $context = null): array
+{
+    error_clear_last();
+    if ($context !== null) {
+        $safeResult = \scandir($directory, $sorting_order, $context);
+    } else {
+        $safeResult = \scandir($directory, $sorting_order);
+    }
+    if ($safeResult === false) {
+        throw DirException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/fileinfo.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\FileinfoException;
+
+/**
+ * This function closes the instance opened by finfo_open.
+ *
+ * @param \finfo $finfo An finfo instance, returned by finfo_open.
+ * @throws FileinfoException
+ *
+ */
+function finfo_close(\finfo $finfo): void
+{
+    error_clear_last();
+    $safeResult = \finfo_close($finfo);
+    if ($safeResult === false) {
+        throw FileinfoException::createFromPhpError();
+    }
+}
+
+
+/**
+ * Procedural style
+ *
+ * Object-oriented style (constructor):
+ *
+ * This function opens a magic database and returns its instance.
+ *
+ * @param int $flags One or disjunction of more Fileinfo
+ * constants.
+ * @param null|string $magic_database Name of a magic database file, usually something like
+ * /path/to/magic.mime. If not specified, the
+ * MAGIC environment variable is used. If the
+ * environment variable isn't set, then PHP's bundled magic database will
+ * be used.
+ *
+ * Passing NULL or an empty string will be equivalent to the default
+ * value.
+ * @return \finfo (Procedural style only)
+ * Returns an finfo instance on success.
+ * @throws FileinfoException
+ *
+ */
+function finfo_open(int $flags = FILEINFO_NONE, ?string $magic_database = null): \finfo
+{
+    error_clear_last();
+    if ($magic_database !== null) {
+        $safeResult = \finfo_open($flags, $magic_database);
+    } else {
+        $safeResult = \finfo_open($flags);
+    }
+    if ($safeResult === false) {
+        throw FileinfoException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * Returns the MIME content type for a file as determined by using
+ * information from the magic.mime file.
+ *
+ * @param resource|string $filename Path to the tested file.
+ * @return string Returns the content type in MIME format, like
+ * text/plain or application/octet-stream.
+ * @throws FileinfoException
+ *
+ */
+function mime_content_type($filename): string
+{
+    error_clear_last();
+    $safeResult = \mime_content_type($filename);
+    if ($safeResult === false) {
+        throw FileinfoException::createFromPhpError();
+    }
+    return $safeResult;
+}

vendor/thecodingmachine/safe/generated/8.2/filter.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Safe;
+
+use Safe\Exceptions\FilterException;
+
+/**
+ * This function is useful for retrieving many values without
+ * repetitively calling filter_input.
+ *
+ * @param int $type One of INPUT_GET, INPUT_POST,
+ * INPUT_COOKIE, INPUT_SERVER, or
+ * INPUT_ENV.
+ * @param array|int $options An array defining the arguments. A valid key is a string
+ * containing a variable name and a valid value is either a filter type, or an array
+ * optionally specifying the filter, flags and options. If the value is an
+ * array, valid keys are filter which specifies the
+ * filter type,
+ * flags which specifies any flags that apply to the
+ * filter, and options which specifies any options that
+ * apply to the filter. See the example below for a better understanding.
+ *
+ * This parameter can be also an integer holding a filter constant. Then all values in the
+ * input array are filtered by this filter.
+ * @param bool $add_empty Add missing keys as NULL to the return value.
+ * @return array|null An array containing the values of the requested variables on success.
+ * If the input array designated by type is not populated,
+ * the function returns NULL if the FILTER_NULL_ON_FAILURE
+ * flag is not given, or FALSE otherwise. For other failures, FALSE is returned.
+ *
+ * An array value will be FALSE if the filter fails, or NULL if
+ * the variable is not set. Or if the flag FILTER_NULL_ON_FAILURE
+ * is used, it returns FALSE if the variable is not set and NULL if the filter
+ * fails. If the add_empty parameter is FALSE, no array
+ * element will be added for unset variables.
+ * @throws FilterException
+ *
+ */
+function filter_input_array(int $type, $options = FILTER_DEFAULT, bool $add_empty = true): ?array
+{
+    error_clear_last();
+    $safeResult = \filter_input_array($type, $options, $add_empty);
+    if ($safeResult === false) {
+        throw FilterException::createFromPhpError();
+    }
+    return $safeResult;
+}
+
+
+/**
+ * This function is useful for retrieving many values without
+ * repetitively calling filter_var.
+ *
+ * @param array $array An array with string keys containing the data to filter.
+ * @param mixed $options An array defining the arguments. A valid key is a string
+ * containing a variable name and a valid value is either a
+ * filter type, or an
+ * array optionally specifying the filter, flags and options.
+ * If the value is an array, valid keys are filter
+ * which specifies the filter type,
+ * flags which specifies any flags that apply to the
+ * filter, and options which specifies any options that
+ * apply to the filter. See the example below for a better understanding.
+ *
+ * This parameter can be also an integer holding a filter constant. Then all values in the
+ * input array are filtered by this filter.
+ * @param bool $add_empty Add missing keys as NULL to the return value.
+ * @return array|null An array containing the values of the requested variables on success. An array value will be FALSE if the filter fails, or NULL if
+ * the variable is not set.
+ * @throws FilterException
+ *
+ */
+function filter_var_array(array $array, $options = FILTER_DEFAULT, bool $add_empty = true): ?array
+{
+    error_clear_last();
+    $safeResult = \filter_var_array($array, $options, $add_empty);
+    if ($safeResult === false) {
+        throw FilterException::createFromPhpError();
+    }
+    return $safeResult;
+}