the scalar value being converted to a boolean.

* The scalar value being converted to an integer *

* The base for the conversion *

* The maximum value depends on the system. 32 bit systems have a * maximum signed integer range of -2147483648 to 2147483647. So for example * on such a system, intval('1000000000000') will return * 2147483647. The maximum signed integer value for 64 bit systems is * 9223372036854775807. *

* Strings will most likely return 0 although this depends on the * leftmost characters of the string. The common rules of * integer casting * apply. */ #[Pure] function intval(mixed $value, int $base = 10): int {} /** * Get float value of a variable * @link https://php.net/manual/en/function.floatval.php * @param mixed $value May be any scalar type. should not be used on objects, as doing so will emit an E_NOTICE level error and return 1. * @return float value of the given variable. Empty arrays return 0, non-empty arrays return 1. */ #[Pure] function floatval(mixed $value): float {} /** * (PHP 4.2.0, PHP 5)
* Alias: * {@see floatval} * Get float value of a variable * @link https://php.net/manual/en/function.doubleval.php * @param mixed $value May be any scalar type. should not be used on objects, as doing so will emit an E_NOTICE level error and return 1. * @return float value of the given variable. Empty arrays return 0, non-empty arrays return 1. */ #[Pure] function doubleval(mixed $value): float {} /** * Get string value of a variable * @link https://php.net/manual/en/function.strval.php * @param mixed $value

* The variable that is being converted to a string. *

* $var may be any scalar type or an object that implements the __toString() method. * You cannot use strval() on arrays or objects that do not implement the __toString() method. *

* The variable being type checked. *

* The variable being converted. *

* Possibles values of type are: *

*
• * "boolean" (or, since PHP 4.2.0, "bool") *
*
• * "integer" (or, since PHP 4.2.0, "int") *
*
• * "float" (only possible since PHP 4.2.0, for older versions use the * deprecated variant "double") *
*
• * "string" *
*
• * "array" *
*
• * "object" *
*
• * "null" (since PHP 4.2.0) *
*

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The value to check *

* If set to TRUE the function only verifies that * name might be a function or method. It will only * reject simple variables that are not strings, or an array that does * not have a valid structure to be used as a callback. The valid ones * are supposed to have only 2 entries, the first of which is an object * or a string, and the second a string. *

* Receives the "callable name". In the example below it is * "someClass::someMethod". Note, however, that despite the implication * that someClass::SomeMethod() is a callable static method, this is not * the case. *

* The file pointer must be valid, and must have been returned by a * successful call to popen. *

* If PHP has been compiled with --enable-sigchild, the return value of this function is undefined. *

* The command *

* The mode *

* If an error occurs, returns false. */ function popen(string $command, string $mode) {} /** * Outputs a file * @link https://php.net/manual/en/function.readfile.php * @param string $filename

* The filename being read. *

* You can use the optional second parameter and set it to true, if * you want to search for the file in the include_path, too. *

* A context stream resource. *

* The file pointer must be valid, and must point to a file * successfully opened by fopen. *

* Path to the directory. *

* The new umask. *

* The file pointer must be valid, and must point to a file successfully * opened by fopen or fsockopen. *

* Reading ends when length - 1 bytes have been * read, on a newline (which is included in the return value), or on EOF * (whichever comes first). If no length is specified, it will keep * reading from the stream until it reaches the end of the line. *

* Until PHP 4.3.0, omitting it would assume 1024 as the line length. * If the majority of the lines in the file are all larger than 8KB, * it is more resource efficient for your script to specify the maximum * line length. *

* If an error occurs, returns false. */ function fgets($stream, ?int $length): string|false {} /** * Gets line from file pointer and strip HTML tags * @link https://php.net/manual/en/function.fgetss.php * @param resource $handle The file pointer must be valid, and must point to a file successfully opened by fopen() or fsockopen() (and not yet closed by fclose()). * @param null|int $length [optional]

* Length of the data to be retrieved. *

* You can use the optional third parameter to specify tags which should * not be stripped. *

* If an error occurs, returns false. * @removed 8.0 */ #[Deprecated(since: '7.3')] function fgetss($handle, ?int $length = null, $allowable_tags = null): false|string {} /** * Binary-safe file read * @link https://php.net/manual/en/function.fread.php * @param resource $stream &fs.file.pointer; * @param int $length

* Up to length number of bytes read. *

* If filename is of the form "scheme://...", it * is assumed to be a URL and PHP will search for a protocol handler * (also known as a wrapper) for that scheme. If no wrappers for that * protocol are registered, PHP will emit a notice to help you track * potential problems in your script and then continue as though * filename specifies a regular file. *

* If PHP has decided that filename specifies * a local file, then it will try to open a stream on that file. * The file must be accessible to PHP, so you need to ensure that * the file access permissions allow this access. * If you have enabled "safemode", * or open_basedir further * restrictions may apply. *

* If PHP has decided that filename specifies * a registered protocol, and that protocol is registered as a * network URL, PHP will check to make sure that * allow_url_fopen is * enabled. If it is switched off, PHP will emit a warning and * the fopen call will fail. *

* The list of supported protocols can be found in . Some protocols (also referred to as * wrappers) support context * and/or "php.ini" options. Refer to the specific page for the * protocol in use for a list of options which can be set. (e.g. * "php.ini" value user_agent used by the * http wrapper). *

* On the Windows platform, be careful to escape any backslashes * used in the path to the file, or use forward slashes. *

 * 
 * 

* The mode parameter specifies the type of access * you require to the stream. It may be any of the following: * * A list of possible modes for fopen * using mode * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

mode	Description
'r'	* Open for reading only; place the file pointer at the * beginning of the file. *
'r+'	* Open for reading and writing; place the file pointer at * the beginning of the file. *
'w'	* Open for writing only; place the file pointer at the * beginning of the file and truncate the file to zero length. * If the file does not exist, attempt to create it. *
'w+'	* Open for reading and writing; place the file pointer at * the beginning of the file and truncate the file to zero * length. If the file does not exist, attempt to create it. *
'a'	* Open for writing only; place the file pointer at the end of * the file. If the file does not exist, attempt to create it. *
'a+'	* Open for reading and writing; place the file pointer at * the end of the file. If the file does not exist, attempt to * create it. *
'x'	* Create and open for writing only; place the file pointer at the * beginning of the file. If the file already exists, the * fopen call will fail by returning false and * generating an error of level E_WARNING. If * the file does not exist, attempt to create it. This is equivalent * to specifying O_EXCL|O_CREAT flags for the * underlying open(2) system call. *
'x+'	* Create and open for reading and writing; place the file pointer at * the beginning of the file. If the file already exists, the * fopen call will fail by returning false and * generating an error of level E_WARNING. If * the file does not exist, attempt to create it. This is equivalent * to specifying O_EXCL|O_CREAT flags for the * underlying open(2) system call. *

*

* Different operating system families have different line-ending * conventions. When you write a text file and want to insert a line * break, you need to use the correct line-ending character(s) for your * operating system. Unix based systems use \n as the * line ending character, Windows based systems use \r\n * as the line ending characters and Macintosh based systems use * \r as the line ending character. *

* If you use the wrong line ending characters when writing your files, you * might find that other applications that open those files will "look * funny". *

* Windows offers a text-mode translation flag ('t') * which will transparently translate \n to * \r\n when working with the file. In contrast, you * can also use 'b' to force binary mode, which will not * translate your data. To use these flags, specify either * 'b' or 't' as the last character * of the mode parameter. *

* The default translation mode depends on the SAPI and version of PHP that * you are using, so you are encouraged to always specify the appropriate * flag for portability reasons. You should use the 't' * mode if you are working with plain-text files and you use * \n to delimit your line endings in your script, but * expect your files to be readable with applications such as notepad. You * should use the 'b' in all other cases. *

* If you do not specify the 'b' flag when working with binary files, you * may experience strange problems with your data, including broken image * files and strange problems with \r\n characters. *

* For portability, it is strongly recommended that you always * use the 'b' flag when opening files with fopen. *

* Again, for portability, it is also strongly recommended that * you re-write code that uses or relies upon the 't' * mode so that it uses the correct line endings and * 'b' mode instead. *

* The optional third use_include_path parameter * can be set to '1' or true if you want to search for the file in the * include_path, too. *

* The file pointer. *

* The handle must be open for writing. *

* The size to truncate to. *

* If size is larger than the file it is extended * with null bytes. *

* If size is smaller than the extra data * will be lost. *

* The offset. *

* To move to a position before the end-of-file, you need to pass * a negative value in offset and * set whence * to SEEK_END. *

* whence values are: * SEEK_SET - Set position equal to offset bytes. * SEEK_CUR - Set position to current location plus offset. * SEEK_END - Set position to end-of-file plus offset. *

* If whence is not specified, it is assumed to be * SEEK_SET. *

* The file pointer must be valid, and must point to a file successfully * opened by fopen or popen. * ftell gives undefined results for append-only streams * (opened with "a" flag). *

* If an error occurs, returns false. */ #[Pure(true)] function ftell($stream): int|false {} /** * Flushes the output to a file * @link https://php.net/manual/en/function.fflush.php * @param resource $stream The file pointer must be valid, and must point to a file successfully opened by fopen() or fsockopen() (and not yet closed by fclose()). * @return bool true on success or false on failure. */ function fflush($stream): bool {} /** * Sync file to storage. Similar to fflush() but blocks until OS buffers have flushed. * @param resource $stream * @since 8.1 */ function fsync($stream): bool {} /** * Sync file data only to storage. Similar to fsync but does not flush modified metadata. POSIX only, aliased to fsync on Win32. * @param resource $stream * @since 8.1 */ function fdatasync($stream): bool {} /** * Binary-safe file write * @link https://php.net/manual/en/function.fwrite.php * @param resource $stream &fs.file.pointer; * @param string $data

* The string that is to be written. *

* If the length argument is given, writing will * stop after length bytes have been written or * the end of string is reached, whichever comes * first. *

* Note that if the length argument is given, * then the magic_quotes_runtime * configuration option will be ignored and no slashes will be * stripped from string. *

* The string that is to be written. *

* If the length argument is given, writing will * stop after length bytes have been written or * the end of string is reached, whichever comes * first. *

* Note that if the length argument is given, * then the magic_quotes_runtime * configuration option will be ignored and no slashes will be * stripped from string. *

* The directory path. *

* The mode is 0777 by default, which means the widest possible * access. For more information on modes, read the details * on the chmod page. *

* mode is ignored on Windows. *

* Note that you probably want to specify the mode as an octal number, * which means it should have a leading zero. The mode is also modified * by the current umask, which you can change using * umask(). *

* Allows the creation of nested directories specified in the pathname. Default to false. *

*

* The old name. The wrapper used in oldname * must match the wrapper used in * newname. *

* The new name. *

* Path to the source file. *

* The destination path. If dest is a URL, the * copy operation may fail if the wrapper does not support overwriting of * existing files. *

* If the destination file already exists, it will be overwritten. *

* A valid context resource created with * stream_context_create. *

* The directory where the temporary filename will be created. *

* The prefix of the generated temporary filename. *

* Path to the file. *

* The optional parameter flags can be one, or * more, of the following constants: *

*
• FILE_USE_INCLUDE_PATH - Search for the file in the include_path.
*
• FILE_IGNORE_NEW_LINES - Omit newline at the end of each array element
*
• FILE_SKIP_EMPTY_LINES - Skip empty lines
*

* A context resource created with the * stream_context_create function. *

* Each line in the resulting array will include the line ending, unless * FILE_IGNORE_NEW_LINES is used, so you still need to * use rtrim if you do not want the line ending * present. *

* Name of the file to read. *

* Note: As of PHP 5 the FILE_USE_INCLUDE_PATH constant can be * used to trigger include path search. *

* A valid context resource created with * stream_context_create. If you don't need to use a * custom context, you can skip this parameter by null. *

* The offset where the reading starts. *

* Maximum length of data read. The default is to read until end * of file is reached. *

* Path to the file where to write the data. *

* The data to write. Can be either a string, an * array or a stream resource. *

* If data is a stream resource, the * remaining buffer of that stream will be copied to the specified file. * This is similar with using stream_copy_to_stream. *

* You can also specify the data parameter as a single * dimension array. This is equivalent to * file_put_contents($filename, implode('', $array)). *

* The value of flags can be any combination of * the following flags (with some restrictions), joined with the binary OR * (|) operator. *

* * Available flags * * * * * * * * * * * * * * * * *

Flag	Description
* FILE_USE_INCLUDE_PATH *	* Search for filename in the include directory. * See include_path for more * information. *
* FILE_APPEND *	* If file filename already exists, append * the data to the file instead of overwriting it. Mutually * exclusive with LOCK_EX since appends are atomic and thus there * is no reason to lock. *
* LOCK_EX *	* Acquire an exclusive lock on the file while proceeding to the * writing. Mutually exclusive with FILE_APPEND. *

*

* A valid context resource created with * stream_context_create. *