pax_global_header 0000666 0000000 0000000 00000000064 15226341625 0014520 g ustar 00root root 0000000 0000000 52 comment=45d07be8dd4b31b6ebe26569f4695066c9eb6d65
vrana-jush-45d07be/ 0000775 0000000 0000000 00000000000 15226341625 0014212 5 ustar 00root root 0000000 0000000 vrana-jush-45d07be/.gitignore 0000664 0000000 0000000 00000000020 15226341625 0016172 0 ustar 00root root 0000000 0000000 vendor/
jush.js
vrana-jush-45d07be/changes.txt 0000664 0000000 0000000 00000007344 15226341625 0016373 0 ustar 00root root 0000000 0000000 JUSH 2.2.2:
Speed up highlighting many elements
MySQL: Highlight vector type and functions
MySQL: Highlight inet4 and inet6 types
Textarea: Defer highlighting to speed up typing and deleting
Textarea: Speed up delete all in Chrome
JUSH 2.2.1:
Fix autocomplete bugs
JUSH 2.2.0:
Add textarea autocomplete
Add autocomplete for SQL
Highlight PHP 8.4
HTML, CSS: Link MDN
Highlight IGDB
JUSH 2.1.3:
Split dark mode
JUSH 2.1.2:
Textarea: Open help on Ctrl+click
JUSH 2.1.1:
Add support for dark mode
Add support for IME composition
PostgreSQL: Fix dollar-quoted strings
MySQL: Fix doc links
MySQL: Lowercase sqlstatus link in MariaDB
JUSH 2.0.0:
Add highlighted textarea
Allow using tags in highlighted source
Highlight PHP 5.5
Highlight HTML5
Highlight CSS 3
Highlight SimpleDB
Highlight keys in JavaScript objects
Highlight hexadecimal numbers
Link Suhosin in php.ini
Link MySQL geometry
Unlink PECL
Help cursor for documentation links
Match regular expressions only once (performance)
JUSH 1.11.0:
Fix jQuery plugin (thanks to Daniel Kouba)
JUSH 1.10.0:
Highlight Oracle
Highlight jsDoc
Highlight text with PHP (e.g. command line scripts)
Highlight MySQL 5.5
Link PHP methods
Link PHP callbacks
Link SQLite PRAGMA
Link PostgreSQL variables
Allow specifying language through class="language-*"
Optionally display title with function summary and parameters
Ability to link custom words (e.g. function or table names)
Highlight tags in 1 second chunks (let browser live)
Fix highlighting in Chrome
JUSH 1.9.0:
Link PHP classes and special functions
Improve performance on multiple calls
Windows command line interface for context help
JUSH 1.8.0:
Highlight MS SQL
Link mail headers
JUSH 1.7.0:
Highlight XML
Highlight phpDoc
Highlight MySQL code comments /*! */
JUSH 1.6.0:
Remove Python (orthogonal)
Option to customize links - e.g. jush.create_links = ' target="_blank"'
Option to highlight only part of document - jush.highlight_tag(dom_elements)
JUSH 1.5.0:
Performance optimizations
Link HTTP headers
Highlight variables inside heredoc
Parse nowdoc (PHP 5.3)
Parse JS regexp only after operator
Highlight
Option to not create links - jush.create_links
Fix CSS comments
JUSH 1.4.0:
Highlighting of Apache config
JUSH 1.3.1:
Highlight MySQL keywords
Link PHP 5.3 keywords
JUSH 1.3.0:
Highlight numbers
JavaScript built-in functions
JUSH 1.2.4:
Links to HTML attributes (lowercase, aliases)
Escape from php_echo by ?>
JUSH 1.2.3:
Bug fixes from Kajman
JUSH 1.2.2:
Highlight Python
Added jush.style()
Highlight HTML in document.write
JUSH 1.2.1:
php.ini highlighting
MySQL data types, missing functions
Don't highlight PHP functions after new
Improve links to PHP keywords
Treat print as echo
JavaScript keywords
SQL variables
JUSH 1.2.0:
PostgreSQL
SQL strings accept ''
SQLite strings not accept \'
Highlight inside sqlite_exec
Document jush.urls
JUSH 1.1.0:
Highlight SQLite
Links to undocumented PgSQL and Socket PHP aliases
JUSH 1.0.4:
Highlight SQL functions and PHP keywords
Jush in class='jush jush-php' not necessary anymore
Remove SET from SQL links (colide with UPDATE SET)
Add jush- prefix to styles
Change to
Change A to A:link
Highlight nearly all links
JUSH 1.0.3:
Highlight PHP also in 'tag'
Decode & as last
Customizable tab width
Preserve tabs in IE
Allow short_open_tag
Add for IE
JUSH 1.0.2:
Recognize functions in mysql_query()
Recognize PHP function language constructs without parentheses
Add style for backticks
JUSH 1.0.1:
Fixes highlight_tag with jush-lang
Uses in highlight_tag
More MySQL commands, links CSS at-rules
Adds A:hover style
Updates installation instructions
JUSH 1.0.0:
Highlight HTML, CSS, JS, PHP and SQL code embedded into each other
Provide links to the documentation for all supported languages
vrana-jush-45d07be/compile.php 0000664 0000000 0000000 00000000357 15226341625 0016360 0 ustar 00root root 0000000 0000000
JUSH - Demo
vrana-jush-45d07be/demo.js 0000664 0000000 0000000 00000001317 15226341625 0015476 0 ustar 00root root 0000000 0000000 (function () {
jush.style('jush.css');
jush.style('jush-dark.css', '(prefers-color-scheme: dark)');
jush.create_links = 'target="_blank"';
var source = document.getElementById('source');
var value = '';
if (!source.value && location.hash) {
source.value = location.hash.substr(1);
}
source.oninput = function highlight() {
if (value == source.value) {
return;
}
value = source.value;
var result = document.getElementById('result');
var language = source.form['language'].value;
result.className = 'jush-' + language;
result.innerHTML = jush.highlight(language, source.value);
};
source.form['language'].onchange = function () {
value = '';
source.oninput();
}
source.oninput();
})();
vrana-jush-45d07be/jquery.jush.js 0000664 0000000 0000000 00000000735 15226341625 0017044 0 ustar 00root root 0000000 0000000 (function ($) {
// include jush.js here
$.jush = jush;
/** Highlight element content
* @param [string]
* @return jQuery
* @this jQuery
*/
$.fn.jush = function (language) {
return this.each(function () {
var lang = language;
var $this = $(this);
if (!lang) {
var match = /(^|\s)(?:jush-|language-)(\S+)/.exec($this.attr('class'));
lang = (match ? match[2] : 'htm');
}
$this.html(jush.highlight(lang, $this.text()));
});
}
})(jQuery);
vrana-jush-45d07be/json.php 0000664 0000000 0000000 00000001374 15226341625 0015701 0 ustar 00root root 0000000 0000000
JSON
vrana-jush-45d07be/jush-api.js 0000664 0000000 0000000 00001701116 15226341625 0016277 0 ustar 00root root 0000000 0000000 jush.api.lowercase_keys = function (obj) {
const result = {};
for (const key in obj) {
result[key.toLowerCase()] = obj[key];
}
return result;
};
jush.api.js = {
'decodeURI': 'Decodes an encoded URI (string)',
'decodeURIComponent': 'Decodes an encoded URI component (string)',
'encodeURI': 'Encodes a string as a URI (string)',
'encodeURIComponent': 'Encodes a string as a URI component (string)',
'escape': 'Encodes a string (string)',
'eval': 'Evaluates a string and executes it as if it was script code (string)',
'isFinite': 'Checks if a value is a finite number (number)',
'isNaN': 'Checks if a value is not a number (number)',
'parseFloat': 'Parses a string and returns a floating point number (string)',
'parseInt': 'Parses a string and returns an integer (string, [radix])',
'unescape': 'Decodes a string encoded by escape() (string)',
'Math.abs': 'Returns the absolute value of a number (x)',
'Math.acos': 'Returns the arccosine of a number (x)',
'Math.asin': 'Returns the arcsine of a number (x)',
'Math.atan': 'Returns the arctangent of x as a numeric value between -PI/2 and PI/2 radians (x)',
'Math.atan2': 'Returns the angle theta of an (x,y) point as a numeric value between -PI and PI radians (y, x)',
'Math.ceil': 'Returns the value of a number rounded upwards to the nearest integer (x)',
'Math.cos': 'Returns the cosine of a number (x)',
'Math.exp': 'Returns the value of Ex (x)',
'Math.floor': 'Returns the value of a number rounded downwards to the nearest integer (x)',
'Math.log': 'Returns the natural logarithm (base E) of a number (x)',
'Math.max': 'Returns the number with the highest value of x and y (x, y)',
'Math.min': 'Returns the number with the lowest value of x and y (x, y)',
'Math.pow': 'Returns the value of x to the power of y (x, y)',
'Math.random': 'Returns a random number between 0 and 1 ()',
'Math.round': 'Rounds a number to the nearest integer (x)',
'Math.sin': 'Returns the sine of a number (x)',
'Math.sqrt': 'Returns the square root of a number (x)',
'Math.tan': 'Returns the tangent of an angle (x)',
'Math.toSource': 'Represents the source code of an object ()',
'Math.valueOf': 'Returns the primitive value of a Math object ()',
'document.close': 'Closes an output stream opened with the document.open() method, and displays the collected data ()',
'document.createAttribute': 'Creates an attribute node with the specified name, and returns the new Attr object (name)',
'document.createCDATASection': 'Creates a CDATA section node (data)',
'document.createComment': 'Creates a comment node (data)',
'document.createDocumentFragment': 'Creates an empty DocumentFragment object, and returns it ()',
'document.createElement': 'Creates an element node (name)',
'document.createTextNode': 'Creates a text node (text)',
'document.getElementById': 'Returns the element that has an ID attribute with the given value. If no such element exists, it returns null (id)',
'document.getElementsByTagName': 'Returns a NodeList of all elements with a specified name (tagname)',
'document.open': 'Opens a stream to collect the output from any document.write() or document.writeln() methods ([mimetype, [replace]])',
'document.write': 'Writes HTML expressions or JavaScript code to a document (s, ...)',
'document.writeln': 'Identical to the write() method, with the addition of writing a new line character after each expression (s, ...)',
'location.assign': 'Loads a new document (url)',
'location.reload': 'Reloads the current document ()',
'location.replace': 'Replaces the current document with a new one (url)',
'window.alert': 'Displays an alert box with a message and an OK button (message)',
'window.blur': 'Removes focus from the current window ()',
'window.clearInterval': 'Cancels a timeout set with setInterval() (id)',
'window.clearTimeout': 'Cancels a timeout set with setTimeout() (id)',
'window.close': 'Closes the current window ()',
'window.confirm': 'Displays a dialog box with a message and an OK and a Cancel button (message)',
'window.focus': 'Sets focus to the current window ()',
'window.moveBy': 'Moves a window relative to its current position (x, y)',
'window.moveTo': 'Moves a window to the specified position (x, y)',
'window.open': 'Opens a new browser window ([url, [name, [specs, [replace]]]])',
'window.print': 'Prints the contents of the current window ()',
'window.prompt': 'Displays a dialog box that prompts the user for input (message, default)',
'window.resizeBy': 'Resizes a window by the specified pixels (width, height)',
'window.resizeTo': 'Resizes a window to the specified width and height (width, height)',
'window.scrollBy': 'Scrolls the content by the specified number of pixels (x, y)',
'window.scrollTo': 'Scrolls the content to the specified coordinates (x, y)',
'window.setInterval': 'Evaluates an expression at specified intervals (fn, milisec)',
'window.setTimeout': 'Evaluates an expression after a specified number of milliseconds (fn, milisec)'
};
jush.api.php2 = jush.api.lowercase_keys({
'ArrayAccess::offsetExists': '(mixed $offset): bool\nWhether an offset exists',
'ArrayAccess::offsetGet': '(mixed $offset): mixed\nOffset to retrieve',
'ArrayAccess::offsetSet': '(mixed $offset, mixed $value): void\nAssign a value to the specified offset',
'ArrayAccess::offsetUnset': '(mixed $offset): void\nUnset an offset',
'BackedEnum::from': '(int|string $value): static\nMaps a scalar to an enum instance',
'BackedEnum::tryFrom': '(int|string $value): static|null\nMaps a scalar to an enum instance or null',
'Closure::bind': '(Closure $closure, object|null $newThis, object|string|null $newScope = "static"): Closure|null\nDuplicates a closure with a specific bound object and class scope',
'Closure::bindTo': '(object|null $newThis, object|string|null $newScope = "static"): Closure|null\nDuplicates the closure with a new bound object and class scope',
'Closure::call': '(object $newThis, mixed ...$args): mixed\nBinds and calls the closure',
'Closure::fromCallable': '(callable $callback): Closure\nConverts a callable into a closure',
'Countable::count': '(): int\nCount elements of an object',
'Error::__clone': '(): void\nClone the error',
'Error::getCode': '(): int\nGets the error code',
'Error::getFile': '(): string\nGets the file in which the error occurred',
'Error::getLine': '(): int\nGets the line in which the error occurred',
'Error::getMessage': '(): string\nGets the error message',
'Error::getPrevious': '(): Throwable|null\nReturns previous Throwable',
'Error::getTrace': '(): array\nGets the stack trace',
'Error::getTraceAsString': '(): string\nGets the stack trace as a string',
'Error::__toString': '(): string\nString representation of the error',
'ErrorException::getSeverity': '(): int\nGets the exception severity',
'Exception::__clone': '(): void\nClone the exception',
'Exception::getCode': '(): int\nGets the Exception code',
'Exception::getFile': '(): string\nGets the file in which the exception was created',
'Exception::getLine': '(): int\nGets the line in which the exception was created',
'Exception::getMessage': '(): string\nGets the Exception message',
'Exception::getPrevious': '(): Throwable|null\nReturns previous Throwable',
'Exception::getTrace': '(): array\nGets the stack trace',
'Exception::getTraceAsString': '(): string\nGets the stack trace as a string',
'Exception::__toString': '(): string\nString representation of the exception',
'Fiber::getCurrent': '(): Fiber|null\nGets the currently executing Fiber instance',
'Fiber::getReturn': '(): mixed\nGets the value returned by the Fiber',
'Fiber::isRunning': '(): bool\nDetermines if the fiber is running',
'Fiber::isStarted': '(): bool\nDetermines if the fiber has started',
'Fiber::isSuspended': '(): bool\nDetermines if the fiber is suspended',
'Fiber::isTerminated': '(): bool\nDetermines if the fiber has terminated',
'Fiber::resume': '(mixed $value = null): mixed\nResumes execution of the fiber with a value',
'Fiber::start': '(mixed ...$args): mixed\nStart execution of the fiber',
'Fiber::suspend': '(mixed $value = null): mixed\nSuspends execution of the current fiber',
'Fiber::throw': '(Throwable $exception): mixed\nResumes execution of the fiber with an exception',
'Generator::current': '(): mixed\nGet the yielded value',
'Generator::getReturn': '(): mixed\nGet the return value of a generator',
'Generator::key': '(): mixed\nGet the yielded key',
'Generator::next': '(): void\nResume execution of the generator',
'Generator::rewind': '(): void\nRewind the generator to the first yield',
'Generator::send': '(mixed $value): mixed\nSend a value to the generator',
'Generator::throw': '(Throwable $exception): mixed\nThrow an exception into the generator',
'Generator::valid': '(): bool\nCheck if the iterator has been closed',
'Generator::__wakeup': '(): void\nSerialize callback',
'InternalIterator::current': '(): mixed\nReturn the current element',
'InternalIterator::key': '(): mixed\nReturn the key of the current element',
'InternalIterator::next': '(): void\nMove forward to next element',
'InternalIterator::rewind': '(): void\nRewind the Iterator to the first element',
'InternalIterator::valid': '(): bool\nCheck if current position is valid',
'Iterator::current': '(): mixed\nReturn the current element',
'Iterator::key': '(): mixed\nReturn the key of the current element',
'Iterator::next': '(): void\nMove forward to next element',
'Iterator::rewind': '(): void\nRewind the Iterator to the first element',
'Iterator::valid': '(): bool\nChecks if current position is valid',
'IteratorAggregate::getIterator': '(): Traversable\nRetrieve an external iterator or traversable',
'SensitiveParameterValue::__debugInfo': '(): array\nProtects the sensitive value against accidental exposure',
'SensitiveParameterValue::getValue': '(): mixed\nReturns the sensitive value',
'Serializable::serialize': '(): string|null\nString representation of object',
'Serializable::unserialize': '(string $data): void\nConstructs the object',
'Stringable::__toString': '(): string\nGets a string representation of the object',
'Throwable::getCode': '(): int\nGets the exception code',
'Throwable::getFile': '(): string\nGets the file in which the object was created',
'Throwable::getLine': '(): int\nGets the line on which the object was instantiated',
'Throwable::getMessage': '(): string\nGets the message',
'Throwable::getPrevious': '(): Throwable|null\nReturns the previous Throwable',
'Throwable::getTrace': '(): array\nGets the stack trace',
'Throwable::getTraceAsString': '(): string\nGets the stack trace as a string',
'Throwable::__toString': '(): string\nGets a string representation of the thrown object',
'UnitEnum::cases': '(): array\nGenerates a list of cases on an enum',
'WeakMap::count': '(): int\nCounts the number of live entries in the map',
'WeakMap::getIterator': '(): Iterator\nRetrieve an external iterator',
'WeakMap::offsetExists': '(object $object): bool\nChecks whether a certain object is in the map',
'WeakMap::offsetGet': '(object $object): mixed\nReturns the value pointed to by a certain object',
'WeakMap::offsetSet': '(object $object, mixed $value): void\nUpdates the map with a new key-value pair',
'WeakMap::offsetUnset': '(object $object): void\nRemoves an entry from the map',
'WeakReference::create': '(object $object): WeakReference\nCreate a new weak reference',
'WeakReference::get': '(): object|null\nGet a weakly referenced Object',
'array_all': '(array $array, callable $callback): bool\nChecks if all array elements satisfy a callback function',
'array_any': '(array $array, callable $callback): bool\nChecks if at least one array element satisfies a callback function',
'array_change_key_case': '(array $array, int $case = CASE_LOWER): array\nChanges the case of all keys in an array',
'array_chunk': '(array $array, int $length, bool $preserve_keys = false): array\nSplit an array into chunks',
'array_column': '(array $array, int|string|null $column_key, int|string|null $index_key = null): array\nReturn the values from a single column in the input array',
'array_combine': '(array $keys, array $values): array\nCreates an array by using one array for keys and another for its values',
'array_count_values': '(array $array): array\nCounts the occurrences of each distinct value in an array',
'array_diff_assoc': '(array $array, array ...$arrays): array\nComputes the difference of arrays with additional index check',
'array_diff_key': '(array $array, array ...$arrays): array\nComputes the difference of arrays using keys for comparison',
'array_diff_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays with additional index check which is performed by a user supplied callback function',
'array_diff_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays using a callback function on the keys for comparison',
'array_diff': '(array $array, array ...$arrays): array\nComputes the difference of arrays',
'array_fill_keys': '(array $keys, mixed $value): array\nFill an array with values, specifying keys',
'array_fill': '(int $start_index, int $count, mixed $value): array\nFill an array with values',
'array_filter': '(array $array, callable|null $callback = null, int $mode = ?): array\nFilters elements of an array using a callback function',
'array_find_key': '(array $array, callable $callback): mixed\nReturns the key of the first element satisfying a callback function',
'array_find': '(array $array, callable $callback): mixed\nReturns the first element satisfying a callback function',
'array_flip': '(array $array): array\nExchanges all keys with their associated values in an array',
'array_intersect_assoc': '(array $array, array ...$arrays): array\nComputes the intersection of arrays with additional index check',
'array_intersect_key': '(array $array, array ...$arrays): array\nComputes the intersection of arrays using keys for comparison',
'array_intersect_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares indexes by a callback function',
'array_intersect_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays using a callback function on the keys for comparison',
'array_intersect': '(array $array, array ...$arrays): array\nComputes the intersection of arrays',
'array_is_list': '(array $array): bool\nChecks whether a given $array is a list',
'array_key_exists': '(string|int|float|bool|resource|null $key, array $array): bool\nChecks if the given key or index exists in the array',
'array_key_first': '(array $array): int|string|null\nGets the first key of an array',
'array_key_last': '(array $array): int|string|null\nGets the last key of an array',
'array_keys': '(array $array): array\nReturn all the keys or a subset of the keys of an array',
'array_keys': '(array $array, mixed $filter_value, bool $strict = false): array\nReturn all the keys or a subset of the keys of an array',
'array_map': '(callable|null $callback, array $array, array ...$arrays): array\nApplies the callback to the elements of the given arrays',
'array_merge_recursive': '(array ...$arrays): array\nMerge one or more arrays recursively',
'array_merge': '(array ...$arrays): array\nMerge one or more arrays',
'array_multisort': '(array $array1, mixed $array1_sort_order = SORT_ASC, mixed $array1_sort_flags = SORT_REGULAR, mixed ...$rest): bool\nSort multiple or multi-dimensional arrays',
'array_pad': '(array $array, int $length, mixed $value): array\nPad array to the specified length with a value',
'array_pop': '(array $array): mixed\nPop the element off the end of array',
'array_product': '(array $array): int|float\nCalculate the product of values in an array',
'array_push': '(array $array, mixed ...$values): int\nPush one or more elements onto the end of array',
'array_rand': '(array $array, int $num = 1): int|string|array\nPick one or more random keys out of an array',
'array_reduce': '(array $array, callable $callback, mixed $initial = null): mixed\nIteratively reduce the array to a single value using a callback function',
'array_replace_recursive': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array recursively',
'array_replace': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array',
'array_reverse': '(array $array, bool $preserve_keys = false): array\nReturn an array with elements in reverse order',
'array_search': '(mixed $needle, array $haystack, bool $strict = false): int|string|false\nSearches the array for a given value and returns the first corresponding key if successful',
'array_shift': '(array $array): mixed\nShift an element off the beginning of array',
'array_slice': '(array $array, int $offset, int|null $length = null, bool $preserve_keys = false): array\nExtract a slice of the array',
'array_splice': '(array $array, int $offset, int|null $length = null, mixed $replacement = []): array\nRemove a portion of the array and replace it with something else',
'array_sum': '(array $array): int|float\nCalculate the sum of values in an array',
'array_udiff_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays with additional index check, compares data by a callback function',
'array_udiff_uassoc': '(array $array, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the difference of arrays with additional index check, compares data and indexes by a callback function',
'array_udiff': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays by using a callback function for data comparison',
'array_uintersect_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays with additional index check, compares data by a callback function',
'array_uintersect_uassoc': '(array $array1, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares data and indexes by separate callback functions',
'array_uintersect': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays, compares data by a callback function',
'array_unique': '(array $array, int $flags = SORT_STRING): array\nRemoves duplicate values from an array',
'array_unshift': '(array $array, mixed ...$values): int\nPrepend one or more elements to the beginning of an array',
'array_values': '(array $array): array\nReturn all the values of an array',
'array_walk_recursive': '(array|object $array, callable $callback, mixed $arg = null): true\nApply a user function recursively to every member of an array',
'array_walk': '(array|object $array, callable $callback, mixed $arg = null): true\nApply a user supplied function to every member of an array',
'array': '(mixed ...$values): array\nCreate an array',
'arsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in descending order and maintain index association',
'asort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in ascending order and maintain index association',
'compact': '(array|string $var_name, array|string ...$var_names): array\nCreate array containing variables and their values',
'count': '(Countable|array $value, int $mode = COUNT_NORMAL): int\nCounts all elements in an array or in a Countable object',
'current': '(array|object $array): mixed\nReturn the current element in an array',
'each': '(array|object $array): array\nReturn the current key and value pair from an array and advance the array cursor',
'end': '(array|object $array): mixed\nSet the internal pointer of an array to its last element',
'extract': '(array $array, int $flags = EXTR_OVERWRITE, string $prefix = ""): int\nImport variables into the current symbol table from an array',
'in_array': '(mixed $needle, array $haystack, bool $strict = false): bool\nChecks if a value exists in an array',
'key_exists': 'Alias of array_key_exists',
'key': '(array|object $array): int|string|null\nFetch a key from an array',
'krsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array by key in descending order',
'ksort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array by key in ascending order',
'list': '(mixed $var, mixed ...$vars = ?): array\nAssign variables as if they were an array',
'natcasesort': '(array $array): true\nSort an array using a case insensitive "natural order" algorithm',
'natsort': '(array $array): true\nSort an array using a "natural order" algorithm',
'next': '(array|object $array): mixed\nAdvance the internal pointer of an array',
'pos': 'Alias of current',
'prev': '(array|object $array): mixed\nRewind the internal array pointer',
'range': '(string|int|float $start, string|int|float $end, int|float $step = 1): array\nCreate an array containing a range of elements',
'reset': '(array|object $array): mixed\nSet the internal pointer of an array to its first element',
'rsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in descending order',
'shuffle': '(array $array): true\nShuffle an array',
'sizeof': 'Alias of count',
'sort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in ascending order',
'uasort': '(array $array, callable $callback): true\nSort an array with a user-defined comparison function and maintain index association',
'uksort': '(array $array, callable $callback): true\nSort an array by keys using a user-defined comparison function',
'usort': '(array $array, callable $callback): true\nSort an array by values using a user-defined comparison function',
'class_alias': '(string $class, string $alias, bool $autoload = true): bool\nCreates an alias for a class',
'class_exists': '(string $class, bool $autoload = true): bool\nChecks if the class has been defined',
'enum_exists': '(string $enum, bool $autoload = true): bool\nChecks if the enum has been defined',
'get_called_class': '(): string\nThe "Late Static Binding" class name',
'get_class_methods': '(object|string $object_or_class): array\nGets the class methods\' names',
'get_class_vars': '(string $class): array\nGet the default properties of the class',
'get_class': '(object $object = ?): string\nReturns the name of the class of an object',
'get_declared_classes': '(): array\nReturns an array with the name of the defined classes',
'get_declared_interfaces': '(): array\nReturns an array of all declared interfaces',
'get_declared_traits': '(): array\nReturns an array of all declared traits',
'get_mangled_object_vars': '(object $object): array\nReturns an array of mangled object properties',
'get_object_vars': '(object $object): array\nGets the properties of the given object',
'get_parent_class': '(object|string $object_or_class = ?): string|false\nRetrieves the parent class name for object or class',
'interface_exists': '(string $interface, bool $autoload = true): bool\nChecks if the interface has been defined',
'is_a': '(mixed $object_or_class, string $class, bool $allow_string = false): bool\nChecks whether the object is of a given type or subtype',
'is_subclass_of': '(mixed $object_or_class, string $class, bool $allow_string = true): bool\nChecks if the object has this class as one of its parents or implements it',
'method_exists': '(object|string $object_or_class, string $method): bool\nChecks if the class method exists',
'property_exists': '(object|string $object_or_class, string $property): bool\nChecks if the object or class has a property',
'trait_exists': '(string $trait, bool $autoload = true): bool\nChecks if the trait exists',
'DateInterval::createFromDateString': '(string $datetime): DateInterval\nSets up a DateInterval from the relative parts of the string',
'date_interval_create_from_date_string': '(string $datetime): DateInterval|false\nSets up a DateInterval from the relative parts of the string',
'DateInterval::format': '(string $format): string\nFormats the interval',
'DatePeriod::createFromISO8601String': '(string $specification, int $options = ?): static\nCreates a new DatePeriod object from an ISO8601 string',
'DatePeriod::getDateInterval': '(): DateInterval\nGets the interval',
'DatePeriod::getEndDate': '(): DateTimeInterface|null\nGets the end date',
'DatePeriod::getRecurrences': '(): int|null\nGets the number of recurrences',
'DatePeriod::getStartDate': '(): DateTimeInterface\nGets the start date',
'DateTime::add': '(DateInterval $interval): DateTime\nModifies a DateTime object, with added amount of days, months, years, hours, minutes and seconds',
'date_add': '(DateTime $object, DateInterval $interval): DateTime\nModifies a DateTime object, with added amount of days, months, years, hours, minutes and seconds',
'DateTime::createFromFormat': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTime|false\nParses a time string according to a specified format',
'date_create_from_format': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTime|false\nParses a time string according to a specified format',
'DateTime::createFromImmutable': '(DateTimeImmutable $object): static\nReturns new DateTime instance encapsulating the given DateTimeImmutable object',
'DateTime::createFromInterface': '(DateTimeInterface $object): DateTime\nReturns new DateTime object encapsulating the given DateTimeInterface object',
'DateTime::getLastErrors': 'Alias of DateTimeImmutable::getLastErrors',
'DateTime::modify': '(string $modifier): DateTime\nAlters the timestamp',
'date_modify': '(DateTime $object, string $modifier): DateTime|false\nAlters the timestamp',
'DateTime::__set_state': '(array $array): DateTime\nThe __set_state handler',
'DateTime::setDate': '(int $year, int $month, int $day): DateTime\nSets the date',
'date_date_set': '(DateTime $object, int $year, int $month, int $day): DateTime\nSets the date',
'DateTime::setISODate': '(int $year, int $week, int $dayOfWeek = 1): DateTime\nSets the ISO date',
'date_isodate_set': '(DateTime $object, int $year, int $week, int $dayOfWeek = 1): DateTime\nSets the ISO date',
'DateTime::setTime': '(int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTime\nSets the time',
'date_time_set': '(DateTime $object, int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTime\nSets the time',
'DateTime::setTimestamp': '(int $timestamp): DateTime\nSets the date and time based on an Unix timestamp',
'date_timestamp_set': '(DateTime $object, int $timestamp): DateTime\nSets the date and time based on an Unix timestamp',
'DateTime::setTimezone': '(DateTimeZone $timezone): DateTime\nSets the time zone for the DateTime object',
'date_timezone_set': '(DateTime $object, DateTimeZone $timezone): DateTime\nSets the time zone for the DateTime object',
'DateTime::sub': '(DateInterval $interval): DateTime\nSubtracts an amount of days, months, years, hours, minutes and seconds from a DateTime object',
'date_sub': '(DateTime $object, DateInterval $interval): DateTime\nSubtracts an amount of days, months, years, hours, minutes and seconds from a DateTime object',
'DateTimeImmutable::add': '(DateInterval $interval): DateTimeImmutable\nReturns a new object, with added amount of days, months, years, hours, minutes and seconds',
'date_create_immutable': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTimeImmutable|false\nReturns new DateTimeImmutable object',
'DateTimeImmutable::createFromFormat': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTimeImmutable|false\nParses a time string according to a specified format',
'date_create_immutable_from_format': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTimeImmutable|false\nParses a time string according to a specified format',
'DateTimeImmutable::createFromInterface': '(DateTimeInterface $object): DateTimeImmutable\nReturns new DateTimeImmutable object encapsulating the given DateTimeInterface object',
'DateTimeImmutable::createFromMutable': '(DateTime $object): static\nReturns new DateTimeImmutable instance encapsulating the given DateTime object',
'DateTimeImmutable::getLastErrors': '(): array|false\nReturns the warnings and errors',
'DateTimeImmutable::modify': '(string $modifier): DateTimeImmutable\nCreates a new object with modified timestamp',
'DateTimeImmutable::__set_state': '(array $array): DateTimeImmutable\nThe __set_state handler',
'DateTimeImmutable::setDate': '(int $year, int $month, int $day): DateTimeImmutable\nSets the date',
'DateTimeImmutable::setISODate': '(int $year, int $week, int $dayOfWeek = 1): DateTimeImmutable\nSets the ISO date',
'DateTimeImmutable::setTime': '(int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTimeImmutable\nSets the time',
'DateTimeImmutable::setTimestamp': '(int $timestamp): DateTimeImmutable\nSets the date and time based on a Unix timestamp',
'DateTimeImmutable::setTimezone': '(DateTimeZone $timezone): DateTimeImmutable\nSets the time zone',
'DateTimeImmutable::sub': '(DateInterval $interval): DateTimeImmutable\nSubtracts an amount of days, months, years, hours, minutes and seconds',
'DateTimeInterface::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
'DateTimeImmutable::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
'DateTime::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
'date_diff': '(DateTimeInterface $baseObject, DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
'DateTimeInterface::format': '(string $format): string\nReturns date formatted according to given format',
'DateTimeImmutable::format': '(string $format): string\nReturns date formatted according to given format',
'DateTime::format': '(string $format): string\nReturns date formatted according to given format',
'date_format': '(DateTimeInterface $object, string $format): string\nReturns date formatted according to given format',
'DateTimeInterface::getOffset': '(): int\nReturns the timezone offset',
'DateTimeImmutable::getOffset': '(): int\nReturns the timezone offset',
'DateTime::getOffset': '(): int\nReturns the timezone offset',
'date_offset_get': '(DateTimeInterface $object): int\nReturns the timezone offset',
'DateTimeInterface::getTimestamp': '(): int\nGets the Unix timestamp',
'DateTimeImmutable::getTimestamp': '(): int\nGets the Unix timestamp',
'DateTime::getTimestamp': '(): int\nGets the Unix timestamp',
'date_timestamp_get': '(DateTimeInterface $object): int\nGets the Unix timestamp',
'DateTimeInterface::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
'DateTimeImmutable::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
'DateTime::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
'date_timezone_get': '(DateTimeInterface $object): DateTimeZone|false\nReturn time zone relative to given DateTime',
'DateTime::__wakeup': '(): void\nThe __wakeup handler',
'DateTimeImmutable::__wakeup': '(): void\nThe __wakeup handler',
'DateTimeInterface::__wakeup': '(): void\nThe __wakeup handler',
'timezone_open': '(string $timezone): DateTimeZone|false\nCreates new DateTimeZone object',
'DateTimeZone::getLocation': '(): array|false\nReturns location information for a timezone',
'timezone_location_get': '(DateTimeZone $object): array|false\nReturns location information for a timezone',
'DateTimeZone::getName': '(): string\nReturns the name of the timezone',
'timezone_name_get': '(DateTimeZone $object): string\nReturns the name of the timezone',
'DateTimeZone::getOffset': '(DateTimeInterface $datetime): int\nReturns the timezone offset from GMT',
'timezone_offset_get': '(DateTimeZone $object, DateTimeInterface $datetime): int\nReturns the timezone offset from GMT',
'DateTimeZone::getTransitions': '(int $timestampBegin = PHP_INT_MIN, int $timestampEnd = PHP_INT_MAX): array|false\nReturns all transitions for the timezone',
'timezone_transitions_get': '(DateTimeZone $object, int $timestampBegin = PHP_INT_MIN, int $timestampEnd = PHP_INT_MAX): array|false\nReturns all transitions for the timezone',
'DateTimeZone::listAbbreviations': '(): array\nReturns associative array containing dst, offset and the timezone name',
'timezone_abbreviations_list': '(): array\nReturns associative array containing dst, offset and the timezone name',
'DateTimeZone::listIdentifiers': '(int $timezoneGroup = DateTimeZone::ALL, string|null $countryCode = null): array\nReturns a numerically indexed array containing all defined timezone identifiers',
'timezone_identifiers_list': '(int $timezoneGroup = DateTimeZone::ALL, string|null $countryCode = null): array\nReturns a numerically indexed array containing all defined timezone identifiers',
'checkdate': '(int $month, int $day, int $year): bool\nValidate a Gregorian date',
'date_add': 'Alias of DateTime::add',
'date_create_from_format': 'Alias of DateTime::createFromFormat',
'date_create_immutable_from_format': 'Alias of DateTimeImmutable::createFromFormat',
'date_create_immutable': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTimeImmutable|false\ncreate a new DateTimeImmutable object',
'date_create': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTime|false\ncreate a new DateTime object',
'date_date_set': 'Alias of DateTime::setDate',
'date_default_timezone_get': '(): string\nGets the default timezone used by all date/time functions in a script',
'date_default_timezone_set': '(string $timezoneId): bool\nSets the default timezone used by all date/time functions in a script',
'date_diff': 'Alias of DateTime::diff',
'date_format': 'Alias of DateTime::format',
'date_get_last_errors': 'Alias of DateTimeImmutable::getLastErrors',
'date_interval_create_from_date_string': 'Alias of DateInterval::createFromDateString',
'date_interval_format': 'Alias of DateInterval::format',
'date_isodate_set': 'Alias of DateTime::setISODate',
'date_modify': 'Alias of DateTime::modify',
'date_offset_get': 'Alias of DateTime::getOffset',
'date_parse_from_format': '(string $format, string $datetime): array\nGet info about given date formatted according to the specified format',
'date_parse': '(string $datetime): array\nReturns associative array with detailed info about given date/time',
'date_sub': 'Alias of DateTime::sub',
'date_sun_info': '(int $timestamp, float $latitude, float $longitude): array\nReturns an array with information about sunset/sunrise and twilight begin/end',
'date_sunrise': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, float|null $latitude = null, float|null $longitude = null, float|null $zenith = null, float|null $utcOffset = null): string|int|float|false\nReturns time of sunrise for a given day and location',
'date_sunset': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, float|null $latitude = null, float|null $longitude = null, float|null $zenith = null, float|null $utcOffset = null): string|int|float|false\nReturns time of sunset for a given day and location',
'date_time_set': 'Alias of DateTime::setTime',
'date_timestamp_get': 'Alias of DateTime::getTimestamp',
'date_timestamp_set': 'Alias of DateTime::setTimestamp',
'date_timezone_get': 'Alias of DateTime::getTimezone',
'date_timezone_set': 'Alias of DateTime::setTimezone',
'date': '(string $format, int|null $timestamp = null): string\nFormat a Unix timestamp',
'getdate': '(int|null $timestamp = null): array\nGet date/time information',
'gettimeofday': '(bool $as_float = false): array|float\nGet current time',
'gmdate': '(string $format, int|null $timestamp = null): string\nFormat a GMT/UTC date/time',
'gmmktime': '(int $hour, int|null $minute = null, int|null $second = null, int|null $month = null, int|null $day = null, int|null $year = null): int|false\nGet Unix timestamp for a GMT date',
'gmstrftime': '(string $format, int|null $timestamp = null): string|false\nFormat a GMT/UTC time/date according to locale settings',
'idate': '(string $format, int|null $timestamp = null): int|false\nFormat a local time/date part as integer',
'localtime': '(int|null $timestamp = null, bool $associative = false): array\nGet the local time',
'microtime': '(bool $as_float = false): string|float\nReturn current Unix timestamp with microseconds',
'mktime': '(int $hour, int|null $minute = null, int|null $second = null, int|null $month = null, int|null $day = null, int|null $year = null): int|false\nGet Unix timestamp for a date',
'strftime': '(string $format, int|null $timestamp = null): string|false\nFormat a local time/date according to locale settings',
'strptime': '(string $timestamp, string $format): array|false\nParse a time/date generated with strftime',
'strtotime': '(string $datetime, int|null $baseTimestamp = null): int|false\nParse about any English textual datetime description into a Unix timestamp',
'time': '(): int\nReturn current Unix timestamp',
'timezone_abbreviations_list': 'Alias of DateTimeZone::listAbbreviations',
'timezone_identifiers_list': 'Alias of DateTimeZone::listIdentifiers',
'timezone_location_get': 'Alias of DateTimeZone::getLocation',
'timezone_name_from_abbr': '(string $abbr, int $utcOffset = -1, int $isDST = -1): string|false\nReturns a timezone name by guessing from abbreviation and UTC offset',
'timezone_name_get': 'Alias of DateTimeZone::getName',
'timezone_offset_get': 'Alias of DateTimeZone::getOffset',
'timezone_open': 'Alias of DateTimeZone::__construct',
'timezone_transitions_get': 'Alias of DateTimeZone::getTransitions',
'timezone_version_get': '(): string\nGets the version of the timezonedb',
'Directory::close': '(): void\nClose directory handle',
'Directory::read': '(): string|false\nRead entry from directory handle',
'Directory::rewind': '(): void\nRewind directory handle',
'chdir': '(string $directory): bool\nChange directory',
'chroot': '(string $directory): bool\nChange the root directory',
'closedir': '(resource|null $dir_handle = null): void\nClose directory handle',
'dir': '(string $directory, resource|null $context = null): Directory|false\nReturn an instance of the Directory class',
'getcwd': '(): string|false\nGets the current working directory',
'opendir': '(string $directory, resource|null $context = null): resource|false\nOpen directory handle',
'readdir': '(resource|null $dir_handle = null): string|false\nRead entry from directory handle',
'rewinddir': '(resource|null $dir_handle = null): void\nRewind directory handle',
'scandir': '(string $directory, int $sorting_order = SCANDIR_SORT_ASCENDING, resource|null $context = null): array|false\nList files and directories inside the specified path',
'debug_backtrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT, int $limit = ?): array\nGenerates a backtrace',
'debug_print_backtrace': '(int $options = ?, int $limit = ?): void\nPrints a backtrace',
'error_clear_last': '(): void\nClear the most recent error',
'error_get_last': '(): array|null\nGet the last occurred error',
'error_log': '(string $message, int $message_type = ?, string|null $destination = null, string|null $additional_headers = null): bool\nSend an error message to the defined error handling routines',
'error_reporting': '(int|null $error_level = null): int\nSets which PHP errors are reported',
'restore_error_handler': '(): true\nRestores the previous error handler function',
'restore_exception_handler': '(): true\nRestores the previously defined exception handler function',
'set_error_handler': '(callable|null $callback, int $error_levels = E_ALL): callable|null\nSets a user-defined error handler function',
'set_exception_handler': '(callable|null $callback): callable|null\nSets a user-defined exception handler function',
'trigger_error': '(string $message, int $error_level = E_USER_NOTICE): true\nGenerates a user-level error/warning/notice message',
'user_error': 'Alias of trigger_error',
'escapeshellarg': '(string $arg): string\nEscape a string to be used as a shell argument',
'escapeshellcmd': '(string $command): string\nEscape shell metacharacters',
'exec': '(string $command, array $output = null, int $result_code = null): string|false\nExecute an external program',
'passthru': '(string $command, int $result_code = null): false|null\nExecute an external program and display raw output',
'proc_close': '(resource $process): int\nClose a process opened by proc_open and return the exit code of that process',
'proc_get_status': '(resource $process): array\nGet information about a process opened by proc_open',
'proc_nice': '(int $priority): bool\nChange the priority of the current process',
'proc_open': '(array|string $command, array $descriptor_spec, array $pipes, string|null $cwd = null, array|null $env_vars = null, array|null $options = null): resource|false\nExecute a command and open file pointers for input/output',
'proc_terminate': '(resource $process, int $signal = 15): bool\nKills a process opened by proc_open',
'shell_exec': '(string $command): string|false|null\nExecute command via shell and return the complete output as a string',
'system': '(string $command, int $result_code = null): string|false\nExecute an external program and display the output',
'basename': '(string $path, string $suffix = ""): string\nReturns trailing name component of path',
'chgrp': '(string $filename, string|int $group): bool\nChanges file group',
'chmod': '(string $filename, int $permissions): bool\nChanges file mode',
'chown': '(string $filename, string|int $user): bool\nChanges file owner',
'clearstatcache': '(bool $clear_realpath_cache = false, string $filename = ""): void\nClears file status cache',
'copy': '(string $from, string $to, resource|null $context = null): bool\nCopies file',
'dirname': '(string $path, int $levels = 1): string\nReturns a parent directory\'s path',
'disk_free_space': '(string $directory): float|false\nReturns available space on filesystem or disk partition',
'disk_total_space': '(string $directory): float|false\nReturns the total size of a filesystem or disk partition',
'diskfreespace': 'Alias of disk_free_space',
'fclose': '(resource $stream): bool\nCloses an open file pointer',
'fdatasync': '(resource $stream): bool\nSynchronizes data (but not meta-data) to the file',
'feof': '(resource $stream): bool\nTests for end-of-file on a file pointer',
'fflush': '(resource $stream): bool\nFlushes the output to a file',
'fgetc': '(resource $stream): string|false\nGets character from file pointer',
'fgetcsv': '(resource $stream, int|null $length = null, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array|false\nGets line from file pointer and parse for CSV fields',
'fgets': '(resource $stream, int|null $length = null): string|false\nGets line from file pointer',
'fgetss': '(resource $handle, int $length = ?, string $allowable_tags = ?): string\nGets line from file pointer and strip HTML tags',
'file_exists': '(string $filename): bool\nChecks whether a file or directory exists',
'file_get_contents': '(string $filename, bool $use_include_path = false, resource|null $context = null, int $offset = ?, int|null $length = null): string|false\nReads entire file into a string',
'file_put_contents': '(string $filename, mixed $data, int $flags = ?, resource|null $context = null): int|false\nWrite data to a file',
'file': '(string $filename, int $flags = ?, resource|null $context = null): array|false\nReads entire file into an array',
'fileatime': '(string $filename): int|false\nGets last access time of file',
'filectime': '(string $filename): int|false\nGets inode change time of file',
'filegroup': '(string $filename): int|false\nGets file group',
'fileinode': '(string $filename): int|false\nGets file inode',
'filemtime': '(string $filename): int|false\nGets file modification time',
'fileowner': '(string $filename): int|false\nGets file owner',
'fileperms': '(string $filename): int|false\nGets file permissions',
'filesize': '(string $filename): int|false\nGets file size',
'filetype': '(string $filename): string|false\nGets file type',
'flock': '(resource $stream, int $operation, int $would_block = null): bool\nPortable advisory file locking',
'fnmatch': '(string $pattern, string $filename, int $flags = ?): bool\nMatch filename against a pattern',
'fopen': '(string $filename, string $mode, bool $use_include_path = false, resource|null $context = null): resource|false\nOpens file or URL',
'fpassthru': '(resource $stream): int\nOutput all remaining data on a file pointer',
'fputcsv': '(resource $stream, array $fields, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\", string $eol = "\\n"): int|false\nFormat line as CSV and write to file pointer',
'fputs': 'Alias of fwrite',
'fread': '(resource $stream, int $length): string|false\nBinary-safe file read',
'fscanf': '(resource $stream, string $format, mixed ...$vars): array|int|false|null\nParses input from a file according to a format',
'fseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeeks on a file pointer',
'fstat': '(resource $stream): array|false\nGets information about a file using an open file pointer',
'fsync': '(resource $stream): bool\nSynchronizes changes to the file (including meta-data)',
'ftell': '(resource $stream): int|false\nReturns the current position of the file read/write pointer',
'ftruncate': '(resource $stream, int $size): bool\nTruncates a file to a given length',
'fwrite': '(resource $stream, string $data, int|null $length = null): int|false\nBinary-safe file write',
'glob': '(string $pattern, int $flags = ?): array|false\nFind pathnames matching a pattern',
'is_dir': '(string $filename): bool\nTells whether the filename is a directory',
'is_executable': '(string $filename): bool\nTells whether the filename is executable',
'is_file': '(string $filename): bool\nTells whether the filename is a regular file',
'is_link': '(string $filename): bool\nTells whether the filename is a symbolic link',
'is_readable': '(string $filename): bool\nTells whether a file exists and is readable',
'is_uploaded_file': '(string $filename): bool\nTells whether the file was uploaded via HTTP POST',
'is_writable': '(string $filename): bool\nTells whether the filename is writable',
'is_writeable': 'Alias of is_writable',
'lchgrp': '(string $filename, string|int $group): bool\nChanges group ownership of symlink',
'lchown': '(string $filename, string|int $user): bool\nChanges user ownership of symlink',
'link': '(string $target, string $link): bool\nCreate a hard link',
'linkinfo': '(string $path): int|false\nGets information about a link',
'lstat': '(string $filename): array|false\nGives information about a file or symbolic link',
'mkdir': '(string $directory, int $permissions = 0777, bool $recursive = false, resource|null $context = null): bool\nMakes directory',
'move_uploaded_file': '(string $from, string $to): bool\nMoves an uploaded file to a new location',
'parse_ini_file': '(string $filename, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration file',
'parse_ini_string': '(string $ini_string, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration string',
'pathinfo': '(string $path, int $flags = PATHINFO_ALL): array|string\nReturns information about a file path',
'pclose': '(resource $handle): int\nCloses process file pointer',
'popen': '(string $command, string $mode): resource|false\nOpens process file pointer',
'readfile': '(string $filename, bool $use_include_path = false, resource|null $context = null): int|false\nOutputs a file',
'readlink': '(string $path): string|false\nReturns the target of a symbolic link',
'realpath_cache_get': '(): array\nGet realpath cache entries',
'realpath_cache_size': '(): int\nGet realpath cache size',
'realpath': '(string $path): string|false\nReturns canonicalized absolute pathname',
'rename': '(string $from, string $to, resource|null $context = null): bool\nRenames a file or directory',
'rewind': '(resource $stream): bool\nRewind the position of a file pointer',
'rmdir': '(string $directory, resource|null $context = null): bool\nRemoves directory',
'set_file_buffer': 'Alias of stream_set_write_buffer',
'stat': '(string $filename): array|false\nGives information about a file',
'symlink': '(string $target, string $link): bool\nCreates a symbolic link',
'tempnam': '(string $directory, string $prefix): string|false\nCreate file with unique file name',
'tmpfile': '(): resource|false\nCreates a temporary file',
'touch': '(string $filename, int|null $mtime = null, int|null $atime = null): bool\nSets access and modification time of file',
'umask': '(int|null $mask = null): int\nChanges the current umask',
'unlink': '(string $filename, resource|null $context = null): bool\nDeletes a file',
'fastcgi_finish_request': '(): bool\nFlushes all response data to the client',
'fpm_get_status': '(): array|false\nReturns the current FPM pool status',
'call_user_func_array': '(callable $callback, array $args): mixed\nCall a callback with an array of parameters',
'call_user_func': '(callable $callback, mixed ...$args): mixed\nCall the callback given by the first parameter',
'create_function': '(string $args, string $code): string\nCreate a function dynamically by evaluating a string of code',
'forward_static_call_array': '(callable $callback, array $args): mixed\nCall a static method and pass the arguments as array',
'forward_static_call': '(callable $callback, mixed ...$args): mixed\nCall a static method',
'func_get_arg': '(int $position): mixed\nReturn an item from the argument list',
'func_get_args': '(): array\nReturns an array comprising a function\'s argument list',
'func_num_args': '(): int\nReturns the number of arguments passed to the function',
'function_exists': '(string $function): bool\nReturn true if the given function has been defined',
'get_defined_functions': '(bool $exclude_disabled = true): array\nReturns an array of all defined functions',
'register_shutdown_function': '(callable $callback, mixed ...$args): void\nRegister a function for execution on shutdown',
'register_tick_function': '(callable $callback, mixed ...$args): bool\nRegister a function for execution on each tick',
'unregister_tick_function': '(callable $callback): void\nDe-register a function for execution on each tick',
'hash_algos': '(): array\nReturn a list of registered hashing algorithms',
'hash_copy': '(HashContext $context): HashContext\nCopy hashing context',
'hash_equals': '(string $known_string, string $user_string): bool\nTiming attack safe string comparison',
'hash_file': '(string $algo, string $filename, bool $binary = false, array $options = []): string|false\nGenerate a hash value using the contents of a given file',
'hash_final': '(HashContext $context, bool $binary = false): string\nFinalize an incremental hash and return resulting digest',
'hash_hkdf': '(string $algo, string $key, int $length = ?, string $info = "", string $salt = ""): string\nGenerate a HKDF key derivation of a supplied key input',
'hash_hmac_algos': '(): array\nReturn a list of registered hashing algorithms suitable for hash_hmac',
'hash_hmac_file': '(string $algo, string $filename, string $key, bool $binary = false): string|false\nGenerate a keyed hash value using the HMAC method and the contents of a given file',
'hash_hmac': '(string $algo, string $data, string $key, bool $binary = false): string\nGenerate a keyed hash value using the HMAC method',
'hash_init': '(string $algo, int $flags = ?, string $key = "", array $options = []): HashContext\nInitialize an incremental hashing context',
'hash_pbkdf2': '(string $algo, string $password, string $salt, int $iterations, int $length = ?, bool $binary = false, array $options = []): string\nGenerate a PBKDF2 key derivation of a supplied password',
'hash_update_file': '(HashContext $context, string $filename, resource|null $stream_context = null): bool\nPump data into an active hashing context from a file',
'hash_update_stream': '(HashContext $context, resource $stream, int $length = -1): int\nPump data into an active hashing context from an open stream',
'hash_update': '(HashContext $context, string $data): true\nPump data into an active hashing context',
'hash': '(string $algo, string $data, bool $binary = false, array $options = []): string\nGenerate a hash value (message digest)',
'HashContext::__serialize': '(): array\nSerializes the HashContext object',
'HashContext::__unserialize': '(array $data): void\nDeserializes the $data parameter into a HashContext object',
'assert_options': '(int $option, mixed $value = ?): mixed\nSet/get the various assert flags',
'assert': '(mixed $assertion, Throwable|string|null $description = null): bool\nChecks an assertion',
'cli_get_process_title': '(): string|null\nReturns the current process title',
'cli_set_process_title': '(string $title): bool\nSets the process title',
'dl': '(string $extension_filename): bool\nLoads a PHP extension at runtime',
'extension_loaded': '(string $extension): bool\nFind out whether an extension is loaded',
'gc_collect_cycles': '(): int\nForces collection of any existing garbage cycles',
'gc_disable': '(): void\nDeactivates the circular reference collector',
'gc_enable': '(): void\nActivates the circular reference collector',
'gc_enabled': '(): bool\nReturns status of the circular reference collector',
'gc_mem_caches': '(): int\nReclaims memory used by the Zend Engine memory manager',
'gc_status': '(): array\nGets information about the garbage collector',
'get_cfg_var': '(string $option): string|array|false\nGets the value of a PHP configuration option',
'get_current_user': '(): string\nGets the name of the owner of the current PHP script',
'get_defined_constants': '(bool $categorize = false): array\nReturns an associative array with the names of all the constants and their values',
'get_extension_funcs': '(string $extension): array|false\nReturns an array with the names of the functions of a module',
'get_include_path': '(): string|false\nGets the current include_path configuration option',
'get_included_files': '(): array\nReturns an array with the names of included or required files',
'get_loaded_extensions': '(bool $zend_extensions = false): array\nReturns an array with the names of all modules compiled and loaded',
'get_magic_quotes_gpc': '(): false\nGets the current configuration setting of magic_quotes_gpc',
'get_magic_quotes_runtime': '(): false\nGets the current active configuration setting of magic_quotes_runtime',
'get_required_files': 'Alias of get_included_files',
'get_resources': '(string|null $type = null): array\nReturns active resources',
'getenv': '(string|null $name = null, bool $local_only = false): string|array|false\nGets the value of a single or all environment variables',
'getlastmod': '(): int|false\nGets time of last page modification',
'getmygid': '(): int|false\nGet PHP script owner\'s GID',
'getmyinode': '(): int|false\nGets the inode of the current script',
'getmypid': '(): int|false\nGets PHP\'s process ID',
'getmyuid': '(): int|false\nGets PHP script owner\'s UID',
'getopt': '(string $short_options, array $long_options = [], int $rest_index = null): array|false\nGets options from the command line argument list',
'getrusage': '(int $mode = ?): array|false\nGets the current resource usages',
'ini_alter': 'Alias of ini_set',
'ini_get_all': '(string|null $extension = null, bool $details = true): array|false\nGets all configuration options',
'ini_get': '(string $option): string|false\nGets the value of a configuration option',
'ini_parse_quantity': '(string $shorthand): int\nGet interpreted size from ini shorthand syntax',
'ini_restore': '(string $option): void\nRestores the value of a configuration option',
'ini_set': '(string $option, string|int|float|bool|null $value): string|false\nSets the value of a configuration option',
'memory_get_peak_usage': '(bool $real_usage = false): int\nReturns the peak of memory allocated by PHP',
'memory_get_usage': '(bool $real_usage = false): int\nReturns the amount of memory allocated to PHP',
'memory_reset_peak_usage': '(): void\nReset the peak memory usage',
'php_ini_loaded_file': '(): string|false\nRetrieve a path to the loaded php.ini file',
'php_ini_scanned_files': '(): string|false\nReturn a list of .ini files parsed from the additional ini dir',
'php_sapi_name': '(): string|false\nReturns the type of interface between web server and PHP',
'php_uname': '(string $mode = "a"): string\nReturns information about the operating system PHP is running on',
'phpcredits': '(int $flags = CREDITS_ALL): true\nPrints out the credits for PHP',
'phpinfo': '(int $flags = INFO_ALL): true\nOutputs information about PHP\'s configuration',
'phpversion': '(string|null $extension = null): string|false\nGets the current PHP version',
'putenv': '(string $assignment): bool\nSets the value of an environment variable',
'restore_include_path': '(): void\nRestores the value of the include_path configuration option',
'set_include_path': '(string $include_path): string|false\nSets the include_path configuration option',
'set_time_limit': '(int $seconds): bool\nLimits the maximum execution time',
'sys_get_temp_dir': '(): string\nReturns directory path used for temporary files',
'version_compare': '(string $version1, string $version2, string|null $operator = null): int|bool\nCompares two "PHP-standardized" version number strings',
'zend_thread_id': '(): int\nReturns a unique identifier for the current thread',
'zend_version': '(): string\nGets the version of the current Zend engine',
'json_decode': '(string $json, bool|null $associative = null, int $depth = 512, int $flags = ?): mixed\nDecodes a JSON string',
'json_encode': '(mixed $value, int $flags = ?, int $depth = 512): string|false\nReturns the JSON representation of a value',
'json_last_error_msg': '(): string\nReturns the error string of the last json_encode() or json_decode() call',
'json_last_error': '(): int\nReturns the last error occurred',
'json_validate': '(string $json, int $depth = 512, int $flags = ?): bool\nChecks if a string contains valid JSON',
'JsonSerializable::jsonSerialize': '(): mixed\nSpecify data which should be serialized to JSON',
'ezmlm_hash': '(string $addr): int\nCalculate the hash value needed by EZMLM',
'mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], string $additional_params = ""): bool\nSend mail',
'abs': '(int|float $num): int|float\nAbsolute value',
'acos': '(float $num): float\nArc cosine',
'acosh': '(float $num): float\nInverse hyperbolic cosine',
'asin': '(float $num): float\nArc sine',
'asinh': '(float $num): float\nInverse hyperbolic sine',
'atan': '(float $num): float\nArc tangent',
'atan2': '(float $y, float $x): float\nArc tangent of two variables',
'atanh': '(float $num): float\nInverse hyperbolic tangent',
'base_convert': '(string $num, int $from_base, int $to_base): string\nConvert a number between arbitrary bases',
'bindec': '(string $binary_string): int|float\nBinary to decimal',
'ceil': '(int|float $num): float\nRound fractions up',
'cos': '(float $num): float\nCosine',
'cosh': '(float $num): float\nHyperbolic cosine',
'decbin': '(int $num): string\nDecimal to binary',
'dechex': '(int $num): string\nDecimal to hexadecimal',
'decoct': '(int $num): string\nDecimal to octal',
'deg2rad': '(float $num): float\nConverts the number in degrees to the radian equivalent',
'exp': '(float $num): float\nCalculates the exponent of e',
'expm1': '(float $num): float\nReturns exp($num) - 1, computed in a way that is accurate even when the value of number is close to zero',
'fdiv': '(float $num1, float $num2): float\nDivides two numbers, according to IEEE 754',
'floor': '(int|float $num): float\nRound fractions down',
'fmod': '(float $num1, float $num2): float\nReturns the floating point remainder (modulo) of the division of the arguments',
'fpow': '(float $num, float $exponent): float\nRaise one number to the power of another, according to IEEE 754',
'hexdec': '(string $hex_string): int|float\nHexadecimal to decimal',
'hypot': '(float $x, float $y): float\nCalculate the length of the hypotenuse of a right-angle triangle',
'intdiv': '(int $num1, int $num2): int\nInteger division',
'is_finite': '(float $num): bool\nChecks whether a float is finite',
'is_infinite': '(float $num): bool\nChecks whether a float is infinite',
'is_nan': '(float $num): bool\nChecks whether a float is NAN',
'log': '(float $num, float $base = M_E): float\nNatural logarithm',
'log10': '(float $num): float\nBase-10 logarithm',
'log1p': '(float $num): float\nReturns log(1 + number), computed in a way that is accurate even when the value of number is close to zero',
'max': '(mixed $value, mixed ...$values): mixed\nFind highest value',
'max': '(array $value_array): mixed\nFind highest value',
'min': '(mixed $value, mixed ...$values): mixed\nFind lowest value',
'min': '(array $value_array): mixed\nFind lowest value',
'octdec': '(string $octal_string): int|float\nOctal to decimal',
'pi': '(): float\nGet value of pi',
'pow': '(mixed $num, mixed $exponent): int|float|object\nExponential expression',
'rad2deg': '(float $num): float\nConverts the radian number to the equivalent number in degrees',
'round': '(int|float $num, int $precision = ?, int|RoundingMode $mode = RoundingMode::HalfAwayFromZero): float\nRounds a float',
'sin': '(float $num): float\nSine',
'sinh': '(float $num): float\nHyperbolic sine',
'sqrt': '(float $num): float\nSquare root',
'tan': '(float $num): float\nTangent',
'tanh': '(float $num): float\nHyperbolic tangent',
'connection_aborted': '(): int\nCheck whether client disconnected',
'connection_status': '(): int\nReturns connection status bitfield',
'constant': '(string $name): mixed\nReturns the value of a constant',
'define': '(string $constant_name, mixed $value, bool $case_insensitive = false): bool\nDefines a named constant',
'defined': '(string $constant_name): bool\nChecks whether a constant with the given name exists',
'die': 'Alias of exit',
'eval': '(string $code): mixed\nEvaluate a string as PHP code',
'exit': '(string|int $status = ?): never\nTerminate the current script with a status code or message',
'get_browser': '(string|null $user_agent = null, bool $return_array = false): object|array|false\nTells what the user\'s browser is capable of',
'highlight_file': '(string $filename, bool $return = false): string|bool\nSyntax highlighting of a file',
'highlight_string': '(string $string, bool $return = false): string|true\nSyntax highlighting of a string',
'hrtime': '(bool $as_number = false): array|int|float|false\nGet the system\'s high resolution time',
'ignore_user_abort': '(bool|null $enable = null): int\nSet whether a client disconnect should abort script execution',
'pack': '(string $format, mixed ...$values): string\nPack data into binary string',
'php_strip_whitespace': '(string $filename): string\nReturn source with stripped comments and whitespace',
'sapi_windows_cp_conv': '(int|string $in_codepage, int|string $out_codepage, string $subject): string|null\nConvert string from one codepage to another',
'sapi_windows_cp_get': '(string $kind = ""): int\nGet current codepage',
'sapi_windows_cp_is_utf8': '(): bool\nIndicates whether the codepage is UTF-8 compatible',
'sapi_windows_cp_set': '(int $codepage): bool\nSet process codepage',
'sapi_windows_generate_ctrl_event': '(int $event, int $pid = ?): bool\nSend a CTRL event to another process',
'sapi_windows_set_ctrl_handler': '(callable|null $handler, bool $add = true): bool\nSet or remove a CTRL event handler',
'sapi_windows_vt100_support': '(resource $stream, bool|null $enable = null): bool\nGet or set VT100 support for the specified stream associated to an output buffer of a Windows console.',
'show_source': 'Alias of highlight_file',
'sleep': '(int $seconds): int\nDelay execution',
'sys_getloadavg': '(): array|false\nGets system load average',
'time_nanosleep': '(int $seconds, int $nanoseconds): array|bool\nDelay for a number of seconds and nanoseconds',
'time_sleep_until': '(float $timestamp): bool\nMake the script sleep until the specified time',
'uniqid': '(string $prefix = "", bool $more_entropy = false): string\nGenerate a time-based identifier',
'unpack': '(string $format, string $string, int $offset = ?): array|false\nUnpack data from binary string',
'usleep': '(int $microseconds): void\nDelay execution in microseconds',
'checkdnsrr': '(string $hostname, string $type = "MX"): bool\nCheck DNS records corresponding to a given Internet host name or IP address',
'closelog': '(): true\nClose connection to system logger',
'dns_check_record': 'Alias of checkdnsrr',
'dns_get_mx': 'Alias of getmxrr',
'dns_get_record': '(string $hostname, int $type = DNS_ANY, array $authoritative_name_servers = null, array $additional_records = null, bool $raw = false): array|false\nFetch DNS Resource Records associated with a hostname',
'fsockopen': '(string $hostname, int $port = -1, int $error_code = null, string $error_message = null, float|null $timeout = null): resource|false\nOpen Internet or Unix domain socket connection',
'gethostbyaddr': '(string $ip): string|false\nGet the Internet host name corresponding to a given IP address',
'gethostbyname': '(string $hostname): string\nGet the IPv4 address corresponding to a given Internet host name',
'gethostbynamel': '(string $hostname): array|false\nGet a list of IPv4 addresses corresponding to a given Internet host name',
'gethostname': '(): string|false\nGets the host name',
'getmxrr': '(string $hostname, array $hosts, array $weights = null): bool\nGet MX records corresponding to a given Internet host name',
'getprotobyname': '(string $protocol): int|false\nGet protocol number associated with protocol name',
'getprotobynumber': '(int $protocol): string|false\nGet protocol name associated with protocol number',
'getservbyname': '(string $service, string $protocol): int|false\nGet port number associated with an Internet service and protocol',
'getservbyport': '(int $port, string $protocol): string|false\nGet Internet service which corresponds to port and protocol',
'header_register_callback': '(callable $callback): bool\nCall a header function',
'header_remove': '(string|null $name = null): void\nRemove previously set headers',
'header': '(string $header, bool $replace = true, int $response_code = ?): void\nSend a raw HTTP header',
'headers_list': '(): array\nReturns a list of response headers sent (or ready to send)',
'headers_sent': '(string $filename = null, int $line = null): bool\nChecks if or where headers have been sent',
'http_clear_last_response_headers': '(): void\nClears the stored HTTP response headers',
'http_get_last_response_headers': '(): array|null\nRetrieve last HTTP response headers',
'http_response_code': '(int $response_code = ?): int|bool\nGet or Set the HTTP response code',
'inet_ntop': '(string $ip): string|false\nConverts a packed internet address to a human readable representation',
'inet_pton': '(string $ip): string|false\nConverts a human readable IP address to its packed in_addr representation',
'ip2long': '(string $ip): int|false\nConverts a string containing an (IPv4) Internet Protocol dotted address into a long integer',
'long2ip': '(int $ip): string\nConverts a long integer address into a string in (IPv4) Internet standard dotted format',
'net_get_interfaces': '(): array|false\nGet network interfaces',
'openlog': '(string $prefix, int $flags, int $facility): true\nOpen connection to system logger',
'pfsockopen': '(string $hostname, int $port = -1, int $error_code = null, string $error_message = null, float|null $timeout = null): resource|false\nOpen persistent Internet or Unix domain socket connection',
'request_parse_body': '(array|null $options = null): array\nRead and parse the request body and return the result',
'setcookie': '(string $name, string $value = "", int $expires_or_options = ?, string $path = "", string $domain = "", bool $secure = false, bool $httponly = false): bool\nSend a cookie',
'setcookie': '(string $name, string $value = "", array $options = []): bool\nSend a cookie',
'setrawcookie': '(string $name, string $value = ?, int $expires_or_options = ?, string $path = ?, string $domain = ?, bool $secure = false, bool $httponly = false): bool\nSend a cookie without urlencoding the cookie value',
'setrawcookie': '(string $name, string $value = ?, array $options = []): bool\nSend a cookie without urlencoding the cookie value',
'socket_get_status': 'Alias of stream_get_meta_data',
'socket_set_blocking': 'Alias of stream_set_blocking',
'socket_set_timeout': 'Alias of stream_set_timeout',
'syslog': '(int $priority, string $message): true\nGenerate a system log message',
'opcache_compile_file': '(string $filename): bool\nCompiles and caches a PHP script without executing it',
'opcache_get_configuration': '(): array|false\nGet configuration information about the cache',
'opcache_get_status': '(bool $include_scripts = true): array|false\nGet status information about the cache',
'opcache_invalidate': '(string $filename, bool $force = false): bool\nInvalidates a cached script',
'opcache_is_script_cached': '(string $filename): bool\nTells whether a script is cached in OPCache',
'opcache_reset': '(): bool\nResets the contents of the opcode cache',
'flush': '(): void\nFlush system output buffer',
'ob_clean': '(): bool\nClean (erase) the contents of the active output buffer',
'ob_end_clean': '(): bool\nClean (erase) the contents of the active output buffer and turn it off',
'ob_end_flush': '(): bool\nFlush (send) the return value of the active output handler and turn the active output buffer off',
'ob_flush': '(): bool\nFlush (send) the return value of the active output handler',
'ob_get_clean': '(): string|false\nGet the contents of the active output buffer and turn it off',
'ob_get_contents': '(): string|false\nReturn the contents of the output buffer',
'ob_get_flush': '(): string|false\nFlush (send) the return value of the active output handler, return the contents of the active output buffer and turn it off',
'ob_get_length': '(): int|false\nReturn the length of the output buffer',
'ob_get_level': '(): int\nReturn the nesting level of the output buffering mechanism',
'ob_get_status': '(bool $full_status = false): array\nGet status of output buffers',
'ob_implicit_flush': '(bool $enable = true): void\nTurn implicit flush on/off',
'ob_list_handlers': '(): array\nList all output handlers in use',
'ob_start': '(callable|null $callback = null, int $chunk_size = ?, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool\nTurn on output buffering',
'output_add_rewrite_var': '(string $name, string $value): bool\nAdd URL rewriter values',
'output_reset_rewrite_vars': '(): bool\nReset URL rewriter values',
'password_algos': '(): array\nGet available password hashing algorithm IDs',
'password_get_info': '(string $hash): array\nReturns information about the given hash',
'password_hash': '(string $password, string|int|null $algo, array $options = []): string\nCreates a password hash',
'password_needs_rehash': '(string $hash, string|int|null $algo, array $options = []): bool\nChecks if the given hash matches the given options',
'password_verify': '(string $password, string $hash): bool\nVerifies that a password matches a hash',
'preg_filter': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int $count = null): string|array|null\nPerform a regular expression search and replace',
'preg_grep': '(string $pattern, array $array, int $flags = ?): array|false\nReturn array entries that match the pattern',
'preg_last_error_msg': '(): string\nReturns the error message of the last PCRE regex execution',
'preg_last_error': '(): int\nReturns the error code of the last PCRE regex execution',
'preg_match_all': '(string $pattern, string $subject, array $matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a global regular expression match',
'preg_match': '(string $pattern, string $subject, array $matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a regular expression match',
'preg_quote': '(string $str, string|null $delimiter = null): string\nQuote regular expression characters',
'preg_replace_callback_array': '(array $pattern, string|array $subject, int $limit = -1, int $count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using callbacks',
'preg_replace_callback': '(string|array $pattern, callable $callback, string|array $subject, int $limit = -1, int $count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using a callback',
'preg_replace': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int $count = null): string|array|null\nPerform a regular expression search and replace',
'preg_split': '(string $pattern, string $subject, int $limit = -1, int $flags = ?): array|false\nSplit string by a regular expression',
'getrandmax': '(): int\nShow largest possible random value',
'lcg_value': '(): float\nCombined linear congruential generator',
'mt_getrandmax': '(): int\nShow largest possible random value',
'mt_rand': '(): int\nGenerate a random value via the Mersenne Twister Random Number Generator',
'mt_rand': '(int $min, int $max): int\nGenerate a random value via the Mersenne Twister Random Number Generator',
'mt_srand': '(int|null $seed = null, int $mode = MT_RAND_MT19937): void\nSeeds the Mersenne Twister Random Number Generator',
'rand': '(): int\nGenerate a random integer',
'rand': '(int $min, int $max): int\nGenerate a random integer',
'random_bytes': '(int $length): string\nGet cryptographically secure random bytes',
'random_int': '(int $min, int $max): int\nGet a cryptographically secure, uniformly selected integer',
'srand': '(int|null $seed = null, int $mode = MT_RAND_MT19937): void\nSeed the random number generator',
'Random\\Engine::generate': '(): string\nGenerates randomness',
'Random\\Engine\\Mt19937::__debugInfo': '(): array\nReturns the internal state of the engine',
'Random\\Engine\\Mt19937::generate': '(): string\nGenerate 32 bits of randomness',
'Random\\Engine\\Mt19937::__serialize': '(): array\nSerializes the Mt19937 object',
'Random\\Engine\\Mt19937::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Mt19937 object',
'Random\\Engine\\PcgOneseq128XslRr64::__debugInfo': '(): array\nReturns the internal state of the engine',
'Random\\Engine\\PcgOneseq128XslRr64::generate': '(): string\nGenerate 64 bits of randomness',
'Random\\Engine\\PcgOneseq128XslRr64::jump': '(int $advance): void\nEfficiently move the engine ahead multiple steps',
'Random\\Engine\\PcgOneseq128XslRr64::__serialize': '(): array\nSerializes the PcgOneseq128XslRr64 object',
'Random\\Engine\\PcgOneseq128XslRr64::__unserialize': '(array $data): void\nDeserializes the $data parameter into a PcgOneseq128XslRr64 object',
'Random\\Engine\\Secure::generate': '(): string\nGenerate cryptographically secure randomness',
'Random\\Engine\\Xoshiro256StarStar::__debugInfo': '(): array\nReturns the internal state of the engine',
'Random\\Engine\\Xoshiro256StarStar::generate': '(): string\nGenerate 64 bits of randomness',
'Random\\Engine\\Xoshiro256StarStar::jump': '(): void\nEfficiently move the engine ahead by 2^128 steps',
'Random\\Engine\\Xoshiro256StarStar::jumpLong': '(): void\nEfficiently move the engine ahead by 2^192 steps',
'Random\\Engine\\Xoshiro256StarStar::__serialize': '(): array\nSerializes the Xoshiro256StarStar object',
'Random\\Engine\\Xoshiro256StarStar::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Xoshiro256StarStar object',
'Random\\Randomizer::getBytes': '(int $length): string\nGet random bytes',
'Random\\Randomizer::getBytesFromString': '(string $string, int $length): string\nGet random bytes from a source string',
'Random\\Randomizer::getFloat': '(float $min, float $max, Random\\IntervalBoundary $boundary = Random\\IntervalBoundary::ClosedOpen): float\nGet a uniformly selected float',
'Random\\Randomizer::getInt': '(int $min, int $max): int\nGet a uniformly selected integer',
'Random\\Randomizer::nextFloat': '(): float\nGet a float from the right-open interval [0.0, 1.0)',
'Random\\Randomizer::nextInt': '(): int\nGet a positive integer',
'Random\\Randomizer::pickArrayKeys': '(array $array, int $num): array\nSelect random array keys',
'Random\\Randomizer::__serialize': '(): array\nSerializes the Randomizer object',
'Random\\Randomizer::shuffleArray': '(array $array): array\nGet a permutation of an array',
'Random\\Randomizer::shuffleBytes': '(string $bytes): string\nGet a byte-wise permutation of a string',
'Random\\Randomizer::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Randomizer object',
'Reflection::export': '(Reflector $reflector, bool $return = false): string\nExports',
'Reflection::getModifierNames': '(int $modifiers): array\nGets modifier names',
'ReflectionAttribute::getArguments': '(): array\nGets arguments passed to attribute',
'ReflectionAttribute::getName': '(): string\nGets attribute name',
'ReflectionAttribute::getTarget': '(): int\nReturns the target of the attribute as bitmask',
'ReflectionAttribute::isRepeated': '(): bool\nReturns whether the attribute of this name has been repeated on a code element',
'ReflectionAttribute::newInstance': '(): object\nInstantiates the attribute class represented by this ReflectionAttribute class and arguments',
'ReflectionClass::export': '(mixed $argument, bool $return = false): string\nExports a class',
'ReflectionClass::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
'ReflectionClass::getConstant': '(string $name): mixed\nGets defined constant',
'ReflectionClass::getConstants': '(int|null $filter = null): array\nGets constants',
'ReflectionClass::getConstructor': '(): ReflectionMethod|null\nGets the constructor of the class',
'ReflectionClass::getDefaultProperties': '(): array\nGets default properties',
'ReflectionClass::getDocComment': '(): string|false\nGets doc comments',
'ReflectionClass::getEndLine': '(): int|false\nGets end line',
'ReflectionClass::getExtension': '(): ReflectionExtension|null\nGets a ReflectionExtension object for the extension which defined the class',
'ReflectionClass::getExtensionName': '(): string|false\nGets the name of the extension which defined the class',
'ReflectionClass::getFileName': '(): string|false\nGets the filename of the file in which the class has been defined',
'ReflectionClass::getInterfaceNames': '(): array\nGets the interface names',
'ReflectionClass::getInterfaces': '(): array\nGets the interfaces',
'ReflectionClass::getLazyInitializer': '(object $object): callable|null\nGets lazy initializer',
'ReflectionClass::getMethod': '(string $name): ReflectionMethod\nGets a ReflectionMethod for a class method',
'ReflectionClass::getMethods': '(int|null $filter = null): array\nGets an array of methods',
'ReflectionClass::getModifiers': '(): int\nGets the class modifiers',
'ReflectionClass::getName': '(): string\nGets class name',
'ReflectionClass::getNamespaceName': '(): string\nGets namespace name',
'ReflectionClass::getParentClass': '(): ReflectionClass|false\nGets parent class',
'ReflectionClass::getProperties': '(int|null $filter = null): array\nGets properties',
'ReflectionClass::getProperty': '(string $name): ReflectionProperty\nGets a ReflectionProperty for a class\'s property',
'ReflectionClass::getReflectionConstant': '(string $name): ReflectionClassConstant|false\nGets a ReflectionClassConstant for a class\'s constant',
'ReflectionClass::getReflectionConstants': '(int|null $filter = null): array\nGets class constants',
'ReflectionClass::getShortName': '(): string\nGets short name',
'ReflectionClass::getStartLine': '(): int|false\nGets starting line number',
'ReflectionClass::getStaticProperties': '(): array\nGets static properties',
'ReflectionClass::getStaticPropertyValue': '(string $name, mixed $def_value = ?): mixed\nGets static property value',
'ReflectionClass::getTraitAliases': '(): array\nReturns an array of trait aliases',
'ReflectionClass::getTraitNames': '(): array\nReturns an array of names of traits used by this class',
'ReflectionClass::getTraits': '(): array\nReturns an array of traits used by this class',
'ReflectionClass::hasConstant': '(string $name): bool\nChecks if constant is defined',
'ReflectionClass::hasMethod': '(string $name): bool\nChecks if method is defined',
'ReflectionClass::hasProperty': '(string $name): bool\nChecks if property is defined',
'ReflectionClass::implementsInterface': '(ReflectionClass|string $interface): bool\nImplements interface',
'ReflectionClass::initializeLazyObject': '(object $object): object\nForces initialization of a lazy object',
'ReflectionClass::inNamespace': '(): bool\nChecks if in namespace',
'ReflectionClass::isAbstract': '(): bool\nChecks if class is abstract',
'ReflectionClass::isAnonymous': '(): bool\nChecks if class is anonymous',
'ReflectionClass::isCloneable': '(): bool\nReturns whether this class is cloneable',
'ReflectionClass::isEnum': '(): bool\nReturns whether this is an enum',
'ReflectionClass::isFinal': '(): bool\nChecks if class is final',
'ReflectionClass::isInstance': '(object $object): bool\nChecks class for instance',
'ReflectionClass::isInstantiable': '(): bool\nChecks if the class is instantiable',
'ReflectionClass::isInterface': '(): bool\nChecks if the class is an interface',
'ReflectionClass::isInternal': '(): bool\nChecks if class is defined internally by an extension, or the core',
'ReflectionClass::isIterable': '(): bool\nCheck whether this class is iterable',
'ReflectionClass::isIterateable': 'Alias of ReflectionClass::isIterable',
'ReflectionClass::isReadOnly': '(): bool\nChecks if class is readonly',
'ReflectionClass::isSubclassOf': '(ReflectionClass|string $class): bool\nChecks if a subclass',
'ReflectionClass::isTrait': '(): bool\nReturns whether this is a trait',
'ReflectionClass::isUninitializedLazyObject': '(object $object): bool\nChecks if an object is lazy and uninitialized',
'ReflectionClass::isUserDefined': '(): bool\nChecks if user defined',
'ReflectionClass::markLazyObjectAsInitialized': '(object $object): object\nMarks a lazy object as initialized without calling the initializer or factory',
'ReflectionClass::newInstance': '(mixed ...$args): object\nCreates a new class instance from given arguments',
'ReflectionClass::newInstanceArgs': '(array $args = []): object|null\nCreates a new class instance from given arguments',
'ReflectionClass::newInstanceWithoutConstructor': '(): object\nCreates a new class instance without invoking the constructor',
'ReflectionClass::newLazyGhost': '(callable $initializer, int $options = ?): object\nCreates a new lazy ghost instance',
'ReflectionClass::newLazyProxy': '(callable $factory, int $options = ?): object\nCreates a new lazy proxy instance',
'ReflectionClass::resetAsLazyGhost': '(object $object, callable $initializer, int $options = ?): void\nResets an object and marks it as lazy',
'ReflectionClass::resetAsLazyProxy': '(object $object, callable $factory, int $options = ?): void\nResets an object and marks it as lazy',
'ReflectionClass::setStaticPropertyValue': '(string $name, mixed $value): void\nSets public static property value',
'ReflectionClass::__toString': '(): string\nReturns the string representation of the ReflectionClass object',
'ReflectionClassConstant::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
'ReflectionClassConstant::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
'ReflectionClassConstant::getDeclaringClass': '(): ReflectionClass\nGets declaring class',
'ReflectionClassConstant::getDocComment': '(): string|false\nGets doc comments',
'ReflectionClassConstant::getModifiers': '(): int\nGets the class constant modifiers',
'ReflectionClassConstant::getName': '(): string\nGet name of the constant',
'ReflectionClassConstant::getType': '(): ReflectionType|null\nGets a class constant\'s type',
'ReflectionClassConstant::getValue': '(): mixed\nGets value',
'ReflectionClassConstant::hasType': '(): bool\nChecks if class constant has a type',
'ReflectionClassConstant::isDeprecated': '(): bool\nChecks if deprecated',
'ReflectionClassConstant::isEnumCase': '(): bool\nChecks if class constant is an Enum case',
'ReflectionClassConstant::isFinal': '(): bool\nChecks if class constant is final',
'ReflectionClassConstant::isPrivate': '(): bool\nChecks if class constant is private',
'ReflectionClassConstant::isProtected': '(): bool\nChecks if class constant is protected',
'ReflectionClassConstant::isPublic': '(): bool\nChecks if class constant is public',
'ReflectionClassConstant::__toString': '(): string\nReturns the string representation of the ReflectionClassConstant object',
'ReflectionConstant::getExtension': '(): ReflectionExtension|null\nGets ReflectionExtension of the defining extension',
'ReflectionConstant::getExtensionName': '(): string|false\nGets name of the defining extension',
'ReflectionConstant::getFileName': '(): string|false\nGets name of the defining file',
'ReflectionConstant::getName': '(): string\nGets name',
'ReflectionConstant::getNamespaceName': '(): string\nGets namespace name',
'ReflectionConstant::getShortName': '(): string\nGets short name',
'ReflectionConstant::getValue': '(): mixed\nGets value',
'ReflectionConstant::isDeprecated': '(): bool\nChecks if deprecated',
'ReflectionConstant::__toString': '(): string\nReturns string representation',
'ReflectionEnum::getBackingType': '(): ReflectionNamedType|null\nGets the backing type of an Enum, if any',
'ReflectionEnum::getCase': '(string $name): ReflectionEnumUnitCase\nReturns a specific case of an Enum',
'ReflectionEnum::getCases': '(): array\nReturns a list of all cases on an Enum',
'ReflectionEnum::hasCase': '(string $name): bool\nChecks for a case on an Enum',
'ReflectionEnum::isBacked': '(): bool\nDetermines if an Enum is a Backed Enum',
'ReflectionEnumBackedCase::getBackingValue': '(): int|string\nGets the scalar value backing this Enum case',
'ReflectionEnumUnitCase::getEnum': '(): ReflectionEnum\nGets the reflection of the enum of this case',
'ReflectionEnumUnitCase::getValue': '(): UnitEnum\nGets the enum case object described by this reflection object',
'ReflectionExtension::__clone': '(): void\nClones',
'ReflectionExtension::export': '(string $name, string $return = false): string\nExport',
'ReflectionExtension::getClasses': '(): array\nGets classes',
'ReflectionExtension::getClassNames': '(): array\nGets class names',
'ReflectionExtension::getConstants': '(): array\nGets constants',
'ReflectionExtension::getDependencies': '(): array\nGets dependencies',
'ReflectionExtension::getFunctions': '(): array\nGets extension functions',
'ReflectionExtension::getINIEntries': '(): array\nGets extension ini entries',
'ReflectionExtension::getName': '(): string\nGets extension name',
'ReflectionExtension::getVersion': '(): string|null\nGets extension version',
'ReflectionExtension::info': '(): void\nPrint extension info',
'ReflectionExtension::isPersistent': '(): bool\nReturns whether this extension is persistent',
'ReflectionExtension::isTemporary': '(): bool\nReturns whether this extension is temporary',
'ReflectionExtension::__toString': '(): string\nTo string',
'ReflectionFiber::getCallable': '(): callable\nGets the callable used to create the Fiber',
'ReflectionFiber::getExecutingFile': '(): string|null\nGet the file name of the current execution point',
'ReflectionFiber::getExecutingLine': '(): int|null\nGet the line number of the current execution point',
'ReflectionFiber::getFiber': '(): Fiber\nGet the reflected Fiber instance',
'ReflectionFiber::getTrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array\nGet the backtrace of the current execution point',
'ReflectionFunction::export': '(string $name, string $return = ?): string\nExports function',
'ReflectionFunction::getClosure': '(): Closure\nReturns a dynamically created closure for the function',
'ReflectionFunction::invoke': '(mixed ...$args): mixed\nInvokes function',
'ReflectionFunction::invokeArgs': '(array $args): mixed\nInvokes function args',
'ReflectionFunction::isAnonymous': '(): bool\nChecks if a function is anonymous',
'ReflectionFunction::isDisabled': '(): bool\nChecks if function is disabled',
'ReflectionFunction::__toString': '(): string\nReturns the string representation of the ReflectionFunction object',
'ReflectionFunctionAbstract::__clone': '(): void\nClones function',
'ReflectionFunctionAbstract::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
'ReflectionFunctionAbstract::getClosureCalledClass': '(): ReflectionClass|null\nReturns the class corresponding to static:: inside a closure',
'ReflectionFunctionAbstract::getClosureScopeClass': '(): ReflectionClass|null\nReturns the class corresponding to the scope inside a closure',
'ReflectionFunctionAbstract::getClosureThis': '(): object|null\nReturns the object which corresponds to $this inside a closure',
'ReflectionFunctionAbstract::getClosureUsedVariables': '(): array\nReturns an array of the used variables in the Closure',
'ReflectionFunctionAbstract::getDocComment': '(): string|false\nGets doc comment',
'ReflectionFunctionAbstract::getEndLine': '(): int|false\nGets end line number',
'ReflectionFunctionAbstract::getExtension': '(): ReflectionExtension|null\nGets extension info',
'ReflectionFunctionAbstract::getExtensionName': '(): string|false\nGets extension name',
'ReflectionFunctionAbstract::getFileName': '(): string|false\nGets file name',
'ReflectionFunctionAbstract::getName': '(): string\nGets function name',
'ReflectionFunctionAbstract::getNamespaceName': '(): string\nGets namespace name',
'ReflectionFunctionAbstract::getNumberOfParameters': '(): int\nGets number of parameters',
'ReflectionFunctionAbstract::getNumberOfRequiredParameters': '(): int\nGets number of required parameters',
'ReflectionFunctionAbstract::getParameters': '(): array\nGets parameters',
'ReflectionFunctionAbstract::getReturnType': '(): ReflectionType|null\nGets the specified return type of a function',
'ReflectionFunctionAbstract::getShortName': '(): string\nGets function short name',
'ReflectionFunctionAbstract::getStartLine': '(): int|false\nGets starting line number',
'ReflectionFunctionAbstract::getStaticVariables': '(): array\nGets static variables',
'ReflectionFunctionAbstract::getTentativeReturnType': '(): ReflectionType|null\nReturns the tentative return type associated with the function',
'ReflectionFunctionAbstract::hasReturnType': '(): bool\nChecks if the function has a specified return type',
'ReflectionFunctionAbstract::hasTentativeReturnType': '(): bool\nReturns whether the function has a tentative return type',
'ReflectionFunctionAbstract::inNamespace': '(): bool\nChecks if function in namespace',
'ReflectionFunctionAbstract::isClosure': '(): bool\nChecks if closure',
'ReflectionFunctionAbstract::isDeprecated': '(): bool\nChecks if deprecated',
'ReflectionFunctionAbstract::isGenerator': '(): bool\nReturns whether this function is a generator',
'ReflectionFunctionAbstract::isInternal': '(): bool\nChecks if is internal',
'ReflectionFunctionAbstract::isStatic': '(): bool\nChecks if the function is static',
'ReflectionFunctionAbstract::isUserDefined': '(): bool\nChecks if user defined',
'ReflectionFunctionAbstract::isVariadic': '(): bool\nChecks if the function is variadic',
'ReflectionFunctionAbstract::returnsReference': '(): bool\nChecks if returns reference',
'ReflectionFunctionAbstract::__toString': '(): void\nReturns the string representation of the ReflectionFunctionAbstract object',
'ReflectionGenerator::getExecutingFile': '(): string\nGets the file name of the currently executing generator',
'ReflectionGenerator::getExecutingGenerator': '(): Generator\nGets the executing Generator object',
'ReflectionGenerator::getExecutingLine': '(): int\nGets the currently executing line of the generator',
'ReflectionGenerator::getFunction': '(): ReflectionFunctionAbstract\nGets the function name of the generator',
'ReflectionGenerator::getThis': '(): object|null\nGets the $this value of the generator',
'ReflectionGenerator::getTrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array\nGets the trace of the executing generator',
'ReflectionGenerator::isClosed': '(): bool\nChecks if execution finished',
'ReflectionIntersectionType::getTypes': '(): array\nReturns the types included in the intersection type',
'ReflectionMethod::createFromMethodName': '(string $method): static\nCreates a new ReflectionMethod',
'ReflectionMethod::export': '(string $class, string $name, bool $return = false): string\nExport a reflection method',
'ReflectionMethod::getClosure': '(object|null $object = null): Closure\nReturns a dynamically created closure for the method',
'ReflectionMethod::getDeclaringClass': '(): ReflectionClass\nGets declaring class for the reflected method',
'ReflectionMethod::getModifiers': '(): int\nGets the method modifiers',
'ReflectionMethod::getPrototype': '(): ReflectionMethod\nGets the method prototype (if there is one)',
'ReflectionMethod::hasPrototype': '(): bool\nReturns whether a method has a prototype',
'ReflectionMethod::invoke': '(object|null $object, mixed ...$args): mixed\nInvoke',
'ReflectionMethod::invokeArgs': '(object|null $object, array $args): mixed\nInvoke args',
'ReflectionMethod::isAbstract': '(): bool\nChecks if method is abstract',
'ReflectionMethod::isConstructor': '(): bool\nChecks if method is a constructor',
'ReflectionMethod::isDestructor': '(): bool\nChecks if method is a destructor',
'ReflectionMethod::isFinal': '(): bool\nChecks if method is final',
'ReflectionMethod::isPrivate': '(): bool\nChecks if method is private',
'ReflectionMethod::isProtected': '(): bool\nChecks if method is protected',
'ReflectionMethod::isPublic': '(): bool\nChecks if method is public',
'ReflectionMethod::setAccessible': '(bool $accessible): void\nSet method accessibility',
'ReflectionMethod::__toString': '(): string\nReturns the string representation of the Reflection method object',
'ReflectionNamedType::getName': '(): string\nGet the name of the type as a string',
'ReflectionNamedType::isBuiltin': '(): bool\nChecks if it is a built-in type',
'ReflectionObject::export': '(string $argument, bool $return = ?): string\nExport',
'ReflectionParameter::allowsNull': '(): bool\nChecks if null is allowed',
'ReflectionParameter::canBePassedByValue': '(): bool\nReturns whether this parameter can be passed by value',
'ReflectionParameter::__clone': '(): void\nClone',
'ReflectionParameter::export': '(string $function, string $parameter, bool $return = ?): string\nExports',
'ReflectionParameter::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
'ReflectionParameter::getClass': '(): ReflectionClass|null\nGet a ReflectionClass object for the parameter being reflected or null',
'ReflectionParameter::getDeclaringClass': '(): ReflectionClass|null\nGets declaring class',
'ReflectionParameter::getDeclaringFunction': '(): ReflectionFunctionAbstract\nGets declaring function',
'ReflectionParameter::getDefaultValue': '(): mixed\nGets default parameter value',
'ReflectionParameter::getDefaultValueConstantName': '(): string|null\nReturns the default value\'s constant name if default value is constant or null',
'ReflectionParameter::getName': '(): string\nGets parameter name',
'ReflectionParameter::getPosition': '(): int\nGets parameter position',
'ReflectionParameter::getType': '(): ReflectionType|null\nGets a parameter\'s type',
'ReflectionParameter::hasType': '(): bool\nChecks if parameter has a type',
'ReflectionParameter::isArray': '(): bool\nChecks if parameter expects an array',
'ReflectionParameter::isCallable': '(): bool\nReturns whether parameter MUST be callable',
'ReflectionParameter::isDefaultValueAvailable': '(): bool\nChecks if a default value is available',
'ReflectionParameter::isDefaultValueConstant': '(): bool\nReturns whether the default value of this parameter is a constant',
'ReflectionParameter::isOptional': '(): bool\nChecks if optional',
'ReflectionParameter::isPassedByReference': '(): bool\nChecks if passed by reference',
'ReflectionParameter::isPromoted': '(): bool\nChecks if a parameter is promoted to a property',
'ReflectionParameter::isVariadic': '(): bool\nChecks if the parameter is variadic',
'ReflectionParameter::__toString': '(): string\nTo string',
'ReflectionProperty::__clone': '(): void\nClone',
'ReflectionProperty::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
'ReflectionProperty::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
'ReflectionProperty::getDeclaringClass': '(): ReflectionClass\nGets declaring class',
'ReflectionProperty::getDefaultValue': '(): mixed\nReturns the default value declared for a property',
'ReflectionProperty::getDocComment': '(): string|false\nGets the property doc comment',
'ReflectionProperty::getHook': '(PropertyHookType $type): ReflectionMethod|null\nReturns a reflection object for a specified hook',
'ReflectionProperty::getHooks': '(): array\nReturns an array of all hooks on this property',
'ReflectionProperty::getModifiers': '(): int\nGets the property modifiers',
'ReflectionProperty::getName': '(): string\nGets property name',
'ReflectionProperty::getRawValue': '(object $object): mixed\nReturns the value of a property, bypassing a get hook if defined',
'ReflectionProperty::getSettableType': '(): ReflectionType|null\nReturns the parameter type of a setter hook',
'ReflectionProperty::getType': '(): ReflectionType|null\nGets a property\'s type',
'ReflectionProperty::getValue': '(object|null $object = null): mixed\nGets value',
'ReflectionProperty::hasDefaultValue': '(): bool\nChecks if property has a default value declared',
'ReflectionProperty::hasHook': '(PropertyHookType $type): bool\nReturns whether the property has a given hook defined',
'ReflectionProperty::hasHooks': '(): bool\nReturns whether the property has any hooks defined',
'ReflectionProperty::hasType': '(): bool\nChecks if property has a type',
'ReflectionProperty::isAbstract': '(): bool\nDetermines if a property is abstract',
'ReflectionProperty::isDefault': '(): bool\nChecks if property is a default property',
'ReflectionProperty::isDynamic': '(): bool\nChecks if property is a dynamic property',
'ReflectionProperty::isFinal': '(): bool\nDetermines if this property is final or not',
'ReflectionProperty::isInitialized': '(object|null $object = null): bool\nChecks whether a property is initialized',
'ReflectionProperty::isLazy': '(object $object): bool\nChecks whether a property is lazy',
'ReflectionProperty::isPrivate': '(): bool\nChecks if property is private',
'ReflectionProperty::isPrivateSet': '(): bool\nChecks if property is private for writing',
'ReflectionProperty::isPromoted': '(): bool\nChecks if property is promoted',
'ReflectionProperty::isProtected': '(): bool\nChecks if property is protected',
'ReflectionProperty::isProtectedSet': '(): bool\nChecks whether the property is protected for writing',
'ReflectionProperty::isPublic': '(): bool\nChecks if property is public',
'ReflectionProperty::isReadOnly': '(): bool\nChecks if property is readonly',
'ReflectionProperty::isStatic': '(): bool\nChecks if property is static',
'ReflectionProperty::isVirtual': '(): bool\nDetermines if a property is virtual',
'ReflectionProperty::setAccessible': '(bool $accessible): void\nSet property accessibility',
'ReflectionProperty::setRawValue': '(object $object, mixed $value): void\nSets the value of a property, bypassing a set hook if defined',
'ReflectionProperty::setRawValueWithoutLazyInitialization': '(object $object, mixed $value): void\nSet raw property value without triggering lazy initialization',
'ReflectionProperty::setValue': '(object|null $object, mixed $value): void\nSet property value',
'ReflectionProperty::setValue': '(mixed $value): void\nSet property value',
'ReflectionProperty::skipLazyInitialization': '(object $object): void\nMarks property as non-lazy',
'ReflectionProperty::__toString': '(): string\nTo string',
'ReflectionReference::fromArrayElement': '(array $array, int|string $key): ReflectionReference|null\nCreate a ReflectionReference from an array element',
'ReflectionReference::getId': '(): string\nGet unique ID of a reference',
'ReflectionType::allowsNull': '(): bool\nChecks if null is allowed',
'ReflectionType::__toString': '(): string\nTo string',
'ReflectionUnionType::getTypes': '(): array\nReturns the types included in the union type',
'ReflectionZendExtension::__clone': '(): void\nClone handler',
'ReflectionZendExtension::export': '(string $name, bool $return = ?): string\nExport',
'ReflectionZendExtension::getAuthor': '(): string\nGets author',
'ReflectionZendExtension::getCopyright': '(): string\nGets copyright',
'ReflectionZendExtension::getName': '(): string\nGets name',
'ReflectionZendExtension::getURL': '(): string\nGets URL',
'ReflectionZendExtension::getVersion': '(): string\nGets version',
'ReflectionZendExtension::__toString': '(): string\nTo string handler',
'Reflector::export': '(): string\nExports',
'AppendIterator::append': '(Iterator $iterator): void\nAppends an iterator',
'AppendIterator::current': '(): mixed\nGets the current value',
'AppendIterator::getArrayIterator': '(): ArrayIterator\nGets the ArrayIterator',
'AppendIterator::getIteratorIndex': '(): int|null\nGets an index of iterators',
'AppendIterator::key': '(): scalar\nGets the current key',
'AppendIterator::next': '(): void\nMoves to the next element',
'AppendIterator::rewind': '(): void\nRewinds the Iterator',
'AppendIterator::valid': '(): bool\nChecks validity of the current element',
'ArrayIterator::append': '(mixed $value): void\nAppend an element',
'ArrayIterator::asort': '(int $flags = SORT_REGULAR): true\nSort entries by values',
'ArrayIterator::count': '(): int\nCount elements',
'ArrayIterator::current': '(): mixed\nReturn current array entry',
'ArrayIterator::getArrayCopy': '(): array\nGet array copy',
'ArrayIterator::getFlags': '(): int\nGet behavior flags',
'ArrayIterator::key': '(): string|int|null\nReturn current array key',
'ArrayIterator::ksort': '(int $flags = SORT_REGULAR): true\nSort entries by keys',
'ArrayIterator::natcasesort': '(): true\nSort entries naturally, case insensitive',
'ArrayIterator::natsort': '(): true\nSort entries naturally',
'ArrayIterator::next': '(): void\nMove to next entry',
'ArrayIterator::offsetExists': '(mixed $key): bool\nCheck if offset exists',
'ArrayIterator::offsetGet': '(mixed $key): mixed\nGet value for an offset',
'ArrayIterator::offsetSet': '(mixed $key, mixed $value): void\nSet value for an offset',
'ArrayIterator::offsetUnset': '(mixed $key): void\nUnset value for an offset',
'ArrayIterator::rewind': '(): void\nRewind array back to the start',
'ArrayIterator::seek': '(int $offset): void\nSeeks to a position',
'ArrayIterator::serialize': '(): string\nSerialize',
'ArrayIterator::setFlags': '(int $flags): void\nSet behaviour flags',
'ArrayIterator::uasort': '(callable $callback): true\nSort with a user-defined comparison function and maintain index association',
'ArrayIterator::uksort': '(callable $callback): true\nSort by keys using a user-defined comparison function',
'ArrayIterator::unserialize': '(string $data): void\nUnserialize',
'ArrayIterator::valid': '(): bool\nCheck whether array contains more entries',
'ArrayObject::append': '(mixed $value): void\nAppends the value',
'ArrayObject::asort': '(int $flags = SORT_REGULAR): true\nSort the entries by value',
'ArrayObject::count': '(): int\nGet the number of public properties in the ArrayObject',
'ArrayObject::exchangeArray': '(array|object $array): array\nExchange the array for another one',
'ArrayObject::getArrayCopy': '(): array\nCreates a copy of the ArrayObject',
'ArrayObject::getFlags': '(): int\nGets the behavior flags',
'ArrayObject::getIterator': '(): Iterator\nCreate a new iterator from an ArrayObject instance',
'ArrayObject::getIteratorClass': '(): string\nGets the iterator classname for the ArrayObject',
'ArrayObject::ksort': '(int $flags = SORT_REGULAR): true\nSort the entries by key',
'ArrayObject::natcasesort': '(): true\nSort an array using a case insensitive "natural order" algorithm',
'ArrayObject::natsort': '(): true\nSort entries using a "natural order" algorithm',
'ArrayObject::offsetExists': '(mixed $key): bool\nReturns whether the requested index exists',
'ArrayObject::offsetGet': '(mixed $key): mixed\nReturns the value at the specified index',
'ArrayObject::offsetSet': '(mixed $key, mixed $value): void\nSets the value at the specified index to newval',
'ArrayObject::offsetUnset': '(mixed $key): void\nUnsets the value at the specified index',
'ArrayObject::serialize': '(): string\nSerialize an ArrayObject',
'ArrayObject::setFlags': '(int $flags): void\nSets the behavior flags',
'ArrayObject::setIteratorClass': '(string $iteratorClass): void\nSets the iterator classname for the ArrayObject',
'ArrayObject::uasort': '(callable $callback): true\nSort the entries with a user-defined comparison function and maintain key association',
'ArrayObject::uksort': '(callable $callback): true\nSort the entries by keys using a user-defined comparison function',
'ArrayObject::unserialize': '(string $data): void\nUnserialize an ArrayObject',
'CachingIterator::count': '(): int\nThe number of elements in the iterator',
'CachingIterator::current': '(): mixed\nReturn the current element',
'CachingIterator::getCache': '(): array\nRetrieve the contents of the cache',
'CachingIterator::getFlags': '(): int\nGet flags used',
'CachingIterator::hasNext': '(): bool\nCheck whether the inner iterator has a valid next element',
'CachingIterator::key': '(): scalar\nReturn the key for the current element',
'CachingIterator::next': '(): void\nMove the iterator forward',
'CachingIterator::offsetExists': '(string $key): bool\nThe offsetExists purpose',
'CachingIterator::offsetGet': '(string $key): mixed\nThe offsetGet purpose',
'CachingIterator::offsetSet': '(string $key, mixed $value): void\nThe offsetSet purpose',
'CachingIterator::offsetUnset': '(string $key): void\nThe offsetUnset purpose',
'CachingIterator::rewind': '(): void\nRewind the iterator',
'CachingIterator::setFlags': '(int $flags): void\nThe setFlags purpose',
'CachingIterator::__toString': '(): string\nReturn the string representation of the current element',
'CachingIterator::valid': '(): bool\nCheck whether the current element is valid',
'CallbackFilterIterator::accept': '(): bool\nCalls the callback with the current value, the current key and the inner iterator as arguments',
'DirectoryIterator::current': '(): mixed\nReturn the current DirectoryIterator item',
'DirectoryIterator::getBasename': '(string $suffix = ""): string\nGet base name of current DirectoryIterator item',
'DirectoryIterator::getExtension': '(): string\nGets the file extension',
'DirectoryIterator::getFilename': '(): string\nReturn file name of current DirectoryIterator item',
'DirectoryIterator::isDot': '(): bool\nDetermine if current DirectoryIterator item is \'.\' or \'..\'',
'DirectoryIterator::key': '(): mixed\nReturn the key for the current DirectoryIterator item',
'DirectoryIterator::next': '(): void\nMove forward to next DirectoryIterator item',
'DirectoryIterator::rewind': '(): void\nRewind the DirectoryIterator back to the start',
'DirectoryIterator::seek': '(int $offset): void\nSeek to a DirectoryIterator item',
'DirectoryIterator::__toString': '(): string\nGet file name as a string',
'DirectoryIterator::valid': '(): bool\nCheck whether current DirectoryIterator position is a valid file',
'EmptyIterator::current': '(): never\nThe current() method',
'EmptyIterator::key': '(): never\nThe key() method',
'EmptyIterator::next': '(): void\nThe next() method',
'EmptyIterator::rewind': '(): void\nThe rewind() method',
'EmptyIterator::valid': '(): false\nChecks whether the current element is valid',
'FilesystemIterator::current': '(): string|SplFileInfo|FilesystemIterator\nThe current file',
'FilesystemIterator::getFlags': '(): int\nGet the handling flags',
'FilesystemIterator::key': '(): string\nRetrieve the key for the current file',
'FilesystemIterator::next': '(): void\nMove to the next file',
'FilesystemIterator::rewind': '(): void\nRewinds back to the beginning',
'FilesystemIterator::setFlags': '(int $flags): void\nSets handling flags',
'FilterIterator::accept': '(): bool\nCheck whether the current element of the iterator is acceptable',
'FilterIterator::current': '(): mixed\nGet the current element value',
'FilterIterator::key': '(): mixed\nGet the current key',
'FilterIterator::next': '(): void\nMove the iterator forward',
'FilterIterator::rewind': '(): void\nRewind the iterator',
'FilterIterator::valid': '(): bool\nCheck whether the current element is valid',
'class_implements': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the interfaces which are implemented by the given class or interface',
'class_parents': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the parent classes of the given class',
'class_uses': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the traits used by the given class',
'iterator_apply': '(Traversable $iterator, callable $callback, array|null $args = null): int\nCall a function for every element in an iterator',
'iterator_count': '(Traversable|array $iterator): int\nCount the elements in an iterator',
'iterator_to_array': '(Traversable|array $iterator, bool $preserve_keys = true): array\nCopy the iterator into an array',
'spl_autoload_call': '(string $class): void\nTry all registered __autoload() functions to load the requested class',
'spl_autoload_extensions': '(string|null $file_extensions = null): string\nRegister and return default file extensions for spl_autoload',
'spl_autoload_functions': '(): array\nReturn all registered __autoload() functions',
'spl_autoload_register': '(callable|null $callback = null, bool $throw = true, bool $prepend = false): bool\nRegister given function as __autoload() implementation',
'spl_autoload_unregister': '(callable $callback): bool\nUnregister given function as __autoload() implementation',
'spl_autoload': '(string $class, string|null $file_extensions = null): void\nDefault implementation for __autoload()',
'spl_classes': '(): array\nReturn available SPL classes',
'spl_object_hash': '(object $object): string\nReturn hash id for given object',
'spl_object_id': '(object $object): int\nReturn the integer object handle for given object',
'GlobIterator::count': '(): int\nGet the number of directories and files',
'InfiniteIterator::next': '(): void\nMoves the inner Iterator forward or rewinds it',
'IteratorIterator::current': '(): mixed\nGet the current value',
'IteratorIterator::getInnerIterator': '(): Iterator|null\nGet the inner iterator',
'IteratorIterator::key': '(): mixed\nGet the key of the current element',
'IteratorIterator::next': '(): void\nForward to the next element',
'IteratorIterator::rewind': '(): void\nRewind to the first element',
'IteratorIterator::valid': '(): bool\nChecks if the current element is valid',
'LimitIterator::current': '(): mixed\nGet current element',
'LimitIterator::getPosition': '(): int\nReturn the current position',
'LimitIterator::key': '(): mixed\nGet current key',
'LimitIterator::next': '(): void\nMove the iterator forward',
'LimitIterator::rewind': '(): void\nRewind the iterator to the specified starting offset',
'LimitIterator::seek': '(int $offset): int\nSeek to the given position',
'LimitIterator::valid': '(): bool\nCheck whether the current element is valid',
'MultipleIterator::attachIterator': '(Iterator $iterator, string|int|null $info = null): void\nAttaches iterator information',
'MultipleIterator::containsIterator': '(Iterator $iterator): bool\nChecks if an iterator is attached',
'MultipleIterator::countIterators': '(): int\nGets the number of attached iterator instances',
'MultipleIterator::current': '(): array\nGets the registered iterator instances',
'MultipleIterator::detachIterator': '(Iterator $iterator): void\nDetaches an iterator',
'MultipleIterator::getFlags': '(): int\nGets the flag information',
'MultipleIterator::key': '(): array\nGets the registered iterator instances',
'MultipleIterator::next': '(): void\nMoves all attached iterator instances forward',
'MultipleIterator::rewind': '(): void\nRewinds all attached iterator instances',
'MultipleIterator::setFlags': '(int $flags): void\nSets flags',
'MultipleIterator::valid': '(): bool\nChecks the validity of sub iterators',
'NoRewindIterator::current': '(): mixed\nGet the current value',
'NoRewindIterator::key': '(): mixed\nGet the current key',
'NoRewindIterator::next': '(): void\nForward to the next element',
'NoRewindIterator::rewind': '(): void\nPrevents the rewind operation on the inner iterator',
'NoRewindIterator::valid': '(): bool\nValidates the iterator',
'OuterIterator::getInnerIterator': '(): Iterator|null\nReturns the inner iterator for the current entry',
'ParentIterator::accept': '(): bool\nDetermines acceptability',
'ParentIterator::getChildren': '(): ParentIterator\nReturn the inner iterator\'s children contained in a ParentIterator',
'ParentIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
'ParentIterator::next': '(): void\nMove the iterator forward',
'ParentIterator::rewind': '(): void\nRewind the iterator',
'RecursiveArrayIterator::getChildren': '(): RecursiveArrayIterator|null\nReturns an iterator for the current entry if it is an array or an object',
'RecursiveArrayIterator::hasChildren': '(): bool\nReturns whether current entry is an array or an object',
'RecursiveCachingIterator::getChildren': '(): RecursiveCachingIterator|null\nReturn the inner iterator\'s children as a RecursiveCachingIterator',
'RecursiveCachingIterator::hasChildren': '(): bool\nCheck whether the current element of the inner iterator has children',
'RecursiveCallbackFilterIterator::getChildren': '(): RecursiveCallbackFilterIterator\nReturn the inner iterator\'s children contained in a RecursiveCallbackFilterIterator',
'RecursiveCallbackFilterIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
'RecursiveDirectoryIterator::getChildren': '(): RecursiveDirectoryIterator\nReturns an iterator for the current entry if it is a directory',
'RecursiveDirectoryIterator::getSubPath': '(): string\nGet sub path',
'RecursiveDirectoryIterator::getSubPathname': '(): string\nGet sub path and name',
'RecursiveDirectoryIterator::hasChildren': '(bool $allowLinks = false): bool\nReturns whether current entry is a directory and not \'.\' or \'..\'',
'RecursiveDirectoryIterator::key': '(): string\nReturn path and filename of current dir entry',
'RecursiveDirectoryIterator::next': '(): void\nMove to next entry',
'RecursiveDirectoryIterator::rewind': '(): void\nRewind dir back to the start',
'RecursiveFilterIterator::getChildren': '(): RecursiveFilterIterator|null\nReturn the inner iterator\'s children contained in a RecursiveFilterIterator',
'RecursiveFilterIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
'RecursiveIterator::getChildren': '(): RecursiveIterator|null\nReturns an iterator for the current entry',
'RecursiveIterator::hasChildren': '(): bool\nReturns if an iterator can be created for the current entry',
'RecursiveIteratorIterator::beginChildren': '(): void\nBegin children',
'RecursiveIteratorIterator::beginIteration': '(): void\nBegin Iteration',
'RecursiveIteratorIterator::callGetChildren': '(): RecursiveIterator|null\nGet children',
'RecursiveIteratorIterator::callHasChildren': '(): bool\nHas children',
'RecursiveIteratorIterator::current': '(): mixed\nAccess the current element value',
'RecursiveIteratorIterator::endChildren': '(): void\nEnd children',
'RecursiveIteratorIterator::endIteration': '(): void\nEnd Iteration',
'RecursiveIteratorIterator::getDepth': '(): int\nGet the current depth of the recursive iteration',
'RecursiveIteratorIterator::getInnerIterator': '(): RecursiveIterator\nGet inner iterator',
'RecursiveIteratorIterator::getMaxDepth': '(): int|false\nGet max depth',
'RecursiveIteratorIterator::getSubIterator': '(int|null $level = null): RecursiveIterator|null\nThe current active sub iterator',
'RecursiveIteratorIterator::key': '(): mixed\nAccess the current key',
'RecursiveIteratorIterator::next': '(): void\nMove forward to the next element',
'RecursiveIteratorIterator::nextElement': '(): void\nNext element',
'RecursiveIteratorIterator::rewind': '(): void\nRewind the iterator to the first element of the top level inner iterator',
'RecursiveIteratorIterator::setMaxDepth': '(int $maxDepth = -1): void\nSet max depth',
'RecursiveIteratorIterator::valid': '(): bool\nCheck whether the current position is valid',
'RecursiveRegexIterator::getChildren': '(): RecursiveRegexIterator\nReturns an iterator for the current entry',
'RecursiveRegexIterator::hasChildren': '(): bool\nReturns whether an iterator can be obtained for the current entry',
'RecursiveTreeIterator::beginChildren': '(): void\nBegin children',
'RecursiveTreeIterator::beginIteration': '(): RecursiveIterator\nBegin iteration',
'RecursiveTreeIterator::callGetChildren': '(): RecursiveIterator\nGet children',
'RecursiveTreeIterator::callHasChildren': '(): bool\nHas children',
'RecursiveTreeIterator::current': '(): mixed\nGet current element',
'RecursiveTreeIterator::endChildren': '(): void\nEnd children',
'RecursiveTreeIterator::endIteration': '(): void\nEnd iteration',
'RecursiveTreeIterator::getEntry': '(): string\nGet current entry',
'RecursiveTreeIterator::getPostfix': '(): string\nGet the postfix',
'RecursiveTreeIterator::getPrefix': '(): string\nGet the prefix',
'RecursiveTreeIterator::key': '(): mixed\nGet the key of the current element',
'RecursiveTreeIterator::next': '(): void\nMove to next element',
'RecursiveTreeIterator::nextElement': '(): void\nNext element',
'RecursiveTreeIterator::rewind': '(): void\nRewind iterator',
'RecursiveTreeIterator::setPostfix': '(string $postfix): void\nSet postfix',
'RecursiveTreeIterator::setPrefixPart': '(int $part, string $value): void\nSet a part of the prefix',
'RecursiveTreeIterator::valid': '(): bool\nCheck validity',
'RegexIterator::accept': '(): bool\nGet accept status',
'RegexIterator::getFlags': '(): int\nGet flags',
'RegexIterator::getMode': '(): int\nReturns operation mode',
'RegexIterator::getPregFlags': '(): int\nReturns the regular expression flags',
'RegexIterator::getRegex': '(): string\nReturns current regular expression',
'RegexIterator::setFlags': '(int $flags): void\nSets the flags',
'RegexIterator::setMode': '(int $mode): void\nSets the operation mode',
'RegexIterator::setPregFlags': '(int $pregFlags): void\nSets the regular expression flags',
'SeekableIterator::seek': '(int $offset): void\nSeeks to a position',
'SplDoublyLinkedList::add': '(int $index, mixed $value): void\nAdd/insert a new value at the specified index',
'SplDoublyLinkedList::bottom': '(): mixed\nPeeks at the node from the beginning of the doubly linked list',
'SplDoublyLinkedList::count': '(): int\nCounts the number of elements in the doubly linked list',
'SplDoublyLinkedList::current': '(): mixed\nReturn current array entry',
'SplDoublyLinkedList::getIteratorMode': '(): int\nReturns the mode of iteration',
'SplDoublyLinkedList::isEmpty': '(): bool\nChecks whether the doubly linked list is empty',
'SplDoublyLinkedList::key': '(): int\nReturn current node index',
'SplDoublyLinkedList::next': '(): void\nMove to next entry',
'SplDoublyLinkedList::offsetExists': '(int $index): bool\nReturns whether the requested $index exists',
'SplDoublyLinkedList::offsetGet': '(int $index): mixed\nReturns the value at the specified $index',
'SplDoublyLinkedList::offsetSet': '(int|null $index, mixed $value): void\nSets the value at the specified $index to $value',
'SplDoublyLinkedList::offsetUnset': '(int $index): void\nUnsets the value at the specified $index',
'SplDoublyLinkedList::pop': '(): mixed\nPops a node from the end of the doubly linked list',
'SplDoublyLinkedList::prev': '(): void\nMove to previous entry',
'SplDoublyLinkedList::push': '(mixed $value): void\nPushes an element at the end of the doubly linked list',
'SplDoublyLinkedList::rewind': '(): void\nRewind iterator back to the start',
'SplDoublyLinkedList::serialize': '(): string\nSerializes the storage',
'SplDoublyLinkedList::setIteratorMode': '(int $mode): int\nSets the mode of iteration',
'SplDoublyLinkedList::shift': '(): mixed\nShifts a node from the beginning of the doubly linked list',
'SplDoublyLinkedList::top': '(): mixed\nPeeks at the node from the end of the doubly linked list',
'SplDoublyLinkedList::unserialize': '(string $data): void\nUnserializes the storage',
'SplDoublyLinkedList::unshift': '(mixed $value): void\nPrepends the doubly linked list with an element',
'SplDoublyLinkedList::valid': '(): bool\nCheck whether the doubly linked list contains more nodes',
'SplFileInfo::getATime': '(): int|false\nGets last access time of the file',
'SplFileInfo::getBasename': '(string $suffix = ""): string\nGets the base name of the file',
'SplFileInfo::getCTime': '(): int|false\nGets the inode change time',
'SplFileInfo::getExtension': '(): string\nGets the file extension',
'SplFileInfo::getFileInfo': '(string|null $class = null): SplFileInfo\nGets an SplFileInfo object for the file',
'SplFileInfo::getFilename': '(): string\nGets the filename',
'SplFileInfo::getGroup': '(): int|false\nGets the file group',
'SplFileInfo::getInode': '(): int|false\nGets the inode for the file',
'SplFileInfo::getLinkTarget': '(): string|false\nGets the target of a link',
'SplFileInfo::getMTime': '(): int|false\nGets the last modified time',
'SplFileInfo::getOwner': '(): int|false\nGets the owner of the file',
'SplFileInfo::getPath': '(): string\nGets the path without filename',
'SplFileInfo::getPathInfo': '(string|null $class = null): SplFileInfo|null\nGets an SplFileInfo object for the path',
'SplFileInfo::getPathname': '(): string\nGets the path to the file',
'SplFileInfo::getPerms': '(): int|false\nGets file permissions',
'SplFileInfo::getRealPath': '(): string|false\nGets absolute path to file',
'SplFileInfo::getSize': '(): int|false\nGets file size',
'SplFileInfo::getType': '(): string|false\nGets file type',
'SplFileInfo::isDir': '(): bool\nTells if the file is a directory',
'SplFileInfo::isExecutable': '(): bool\nTells if the file is executable',
'SplFileInfo::isFile': '(): bool\nTells if the object references a regular file',
'SplFileInfo::isLink': '(): bool\nTells if the file is a link',
'SplFileInfo::isReadable': '(): bool\nTells if file is readable',
'SplFileInfo::isWritable': '(): bool\nTells if the entry is writable',
'SplFileInfo::openFile': '(string $mode = "r", bool $useIncludePath = false, resource|null $context = null): SplFileObject\nGets an SplFileObject object for the file',
'SplFileInfo::setFileClass': '(string $class = SplFileObject::class): void\nSets the class used with SplFileInfo::openFile',
'SplFileInfo::setInfoClass': '(string $class = SplFileInfo::class): void\nSets the class used with SplFileInfo::getFileInfo and SplFileInfo::getPathInfo',
'SplFileInfo::__toString': '(): string\nReturns the path to the file as a string',
'SplFileObject::current': '(): string|array|false\nRetrieve current line of file',
'SplFileObject::eof': '(): bool\nReached end of file',
'SplFileObject::fflush': '(): bool\nFlushes the output to the file',
'SplFileObject::fgetc': '(): string|false\nGets character from file',
'SplFileObject::fgetcsv': '(string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array|false\nGets line from file and parse as CSV fields',
'SplFileObject::fgets': '(): string\nGets line from file',
'SplFileObject::fgetss': '(string $allowable_tags = ?): string\nGets line from file and strip HTML tags',
'SplFileObject::flock': '(int $operation, int $wouldBlock = null): bool\nPortable file locking',
'SplFileObject::fpassthru': '(): int\nOutput all remaining data on a file pointer',
'SplFileObject::fputcsv': '(array $fields, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\", string $eol = "\\n"): int|false\nWrite a field array as a CSV line',
'SplFileObject::fread': '(int $length): string|false\nRead from file',
'SplFileObject::fscanf': '(string $format, mixed ...$vars): array|int|null\nParses input from file according to a format',
'SplFileObject::fseek': '(int $offset, int $whence = SEEK_SET): int\nSeek to a position',
'SplFileObject::fstat': '(): array\nGets information about the file',
'SplFileObject::ftell': '(): int|false\nReturn current file position',
'SplFileObject::ftruncate': '(int $size): bool\nTruncates the file to a given length',
'SplFileObject::fwrite': '(string $data, int $length = ?): int|false\nWrite to file',
'SplFileObject::getChildren': '(): null\nNo purpose',
'SplFileObject::getCsvControl': '(): array\nGet the delimiter, enclosure and escape character for CSV',
'SplFileObject::getCurrentLine': 'Alias of SplFileObject::fgets',
'SplFileObject::getFlags': '(): int\nGets flags for the SplFileObject',
'SplFileObject::getMaxLineLen': '(): int\nGet maximum line length',
'SplFileObject::hasChildren': '(): false\nSplFileObject does not have children',
'SplFileObject::key': '(): int\nGet line number',
'SplFileObject::next': '(): void\nRead next line',
'SplFileObject::rewind': '(): void\nRewind the file to the first line',
'SplFileObject::seek': '(int $line): void\nSeek to specified line',
'SplFileObject::setCsvControl': '(string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): void\nSet the delimiter, enclosure and escape character for CSV',
'SplFileObject::setFlags': '(int $flags): void\nSets flags for the SplFileObject',
'SplFileObject::setMaxLineLen': '(int $maxLength): void\nSet maximum line length',
'SplFileObject::__toString': '(): string\nReturns the current line as a string',
'SplFileObject::valid': '(): bool\nNot at EOF',
'SplFixedArray::count': '(): int\nReturns the size of the array',
'SplFixedArray::current': '(): mixed\nReturn current array entry',
'SplFixedArray::fromArray': '(array $array, bool $preserveKeys = true): SplFixedArray\nImport a PHP array in a SplFixedArray instance',
'SplFixedArray::getIterator': '(): Iterator\nRetrieve the iterator to go through the array',
'SplFixedArray::getSize': '(): int\nGets the size of the array',
'SplFixedArray::jsonSerialize': '(): array\nReturns a representation that can be converted to JSON',
'SplFixedArray::key': '(): int\nReturn current array index',
'SplFixedArray::next': '(): void\nMove to next entry',
'SplFixedArray::offsetExists': '(int $index): bool\nReturns whether the requested index exists',
'SplFixedArray::offsetGet': '(int $index): mixed\nReturns the value at the specified index',
'SplFixedArray::offsetSet': '(int $index, mixed $value): void\nSets a new value at a specified index',
'SplFixedArray::offsetUnset': '(int $index): void\nUnsets the value at the specified $index',
'SplFixedArray::rewind': '(): void\nRewind iterator back to the start',
'SplFixedArray::__serialize': '(): array\nSerializes the SplFixedArray object',
'SplFixedArray::setSize': '(int $size): true\nChange the size of an array',
'SplFixedArray::toArray': '(): array\nReturns a PHP array from the fixed array',
'SplFixedArray::__unserialize': '(array $data): void\nDeserializes the $data parameter into an SplFixedArray object',
'SplFixedArray::valid': '(): bool\nCheck whether the array contains more elements',
'SplFixedArray::__wakeup': '(): void\nReinitialises the array after being unserialised',
'SplHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
'SplHeap::count': '(): int\nCounts the number of elements in the heap',
'SplHeap::current': '(): mixed\nReturn current node pointed by the iterator',
'SplHeap::extract': '(): mixed\nExtracts a node from top of the heap and sift up',
'SplHeap::insert': '(mixed $value): true\nInserts an element in the heap by sifting it up',
'SplHeap::isCorrupted': '(): bool\nTells if the heap is in a corrupted state',
'SplHeap::isEmpty': '(): bool\nChecks whether the heap is empty',
'SplHeap::key': '(): int\nReturn current node index',
'SplHeap::next': '(): void\nMove to the next node',
'SplHeap::recoverFromCorruption': '(): true\nRecover from the corrupted state and allow further actions on the heap',
'SplHeap::rewind': '(): void\nRewind iterator back to the start (no-op)',
'SplHeap::top': '(): mixed\nPeeks at the node from the top of the heap',
'SplHeap::valid': '(): bool\nCheck whether the heap contains more nodes',
'SplMaxHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
'SplMinHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
'SplObjectStorage::addAll': '(SplObjectStorage $storage): int\nAdds all objects from another storage',
'SplObjectStorage::attach': '(object $object, mixed $info = null): void\nAdds an object in the storage',
'SplObjectStorage::contains': '(object $object): bool\nChecks if the storage contains a specific object',
'SplObjectStorage::count': '(int $mode = COUNT_NORMAL): int\nReturns the number of objects in the storage',
'SplObjectStorage::current': '(): object\nReturns the current storage entry',
'SplObjectStorage::detach': '(object $object): void\nRemoves an object from the storage',
'SplObjectStorage::getHash': '(object $object): string\nCalculate a unique identifier for the contained objects',
'SplObjectStorage::getInfo': '(): mixed\nReturns the data associated with the current iterator entry',
'SplObjectStorage::key': '(): int\nReturns the index at which the iterator currently is',
'SplObjectStorage::next': '(): void\nMove to the next entry',
'SplObjectStorage::offsetExists': '(object $object): bool\nChecks whether an object exists in the storage',
'SplObjectStorage::offsetGet': '(object $object): mixed\nReturns the data associated with an object',
'SplObjectStorage::offsetSet': '(object $object, mixed $info = null): void\nAssociates data to an object in the storage',
'SplObjectStorage::offsetUnset': '(object $object): void\nRemoves an object from the storage',
'SplObjectStorage::removeAll': '(SplObjectStorage $storage): int\nRemoves objects contained in another storage from the current storage',
'SplObjectStorage::removeAllExcept': '(SplObjectStorage $storage): int\nRemoves all objects except for those contained in another storage from the current storage',
'SplObjectStorage::rewind': '(): void\nRewind the iterator to the first storage element',
'SplObjectStorage::seek': '(int $offset): void\nSeeks iterator to a position',
'SplObjectStorage::serialize': '(): string\nSerializes the storage',
'SplObjectStorage::setInfo': '(mixed $info): void\nSets the data associated with the current iterator entry',
'SplObjectStorage::unserialize': '(string $data): void\nUnserializes a storage from its string representation',
'SplObjectStorage::valid': '(): bool\nReturns if the current iterator entry is valid',
'SplObserver::update': '(SplSubject $subject): void\nReceive update from subject',
'SplPriorityQueue::compare': '(mixed $priority1, mixed $priority2): int\nCompare priorities in order to place elements correctly in the heap while sifting up',
'SplPriorityQueue::count': '(): int\nCounts the number of elements in the queue',
'SplPriorityQueue::current': '(): mixed\nReturn current node pointed by the iterator',
'SplPriorityQueue::extract': '(): mixed\nExtracts a node from top of the heap and sift up',
'SplPriorityQueue::getExtractFlags': '(): int\nGet the flags of extraction',
'SplPriorityQueue::insert': '(mixed $value, mixed $priority): true\nInserts an element in the queue by sifting it up',
'SplPriorityQueue::isCorrupted': '(): bool\nTells if the priority queue is in a corrupted state',
'SplPriorityQueue::isEmpty': '(): bool\nChecks whether the queue is empty',
'SplPriorityQueue::key': '(): int\nReturn current node index',
'SplPriorityQueue::next': '(): void\nMove to the next node',
'SplPriorityQueue::recoverFromCorruption': '(): true\nRecover from the corrupted state and allow further actions on the queue',
'SplPriorityQueue::rewind': '(): void\nRewind iterator back to the start (no-op)',
'SplPriorityQueue::setExtractFlags': '(int $flags): int\nSets the mode of extraction',
'SplPriorityQueue::top': '(): mixed\nPeeks at the node from the top of the queue',
'SplPriorityQueue::valid': '(): bool\nCheck whether the queue contains more nodes',
'SplQueue::dequeue': '(): mixed\nDequeues a node from the queue',
'SplQueue::enqueue': '(mixed $value): void\nAdds an element to the queue',
'SplSubject::attach': '(SplObserver $observer): void\nAttach an SplObserver',
'SplSubject::detach': '(SplObserver $observer): void\nDetach an observer',
'SplSubject::notify': '(): void\nNotify an observer',
'stream_bucket_append': '(resource $brigade, StreamBucket $bucket): void\nAppend bucket to brigade',
'stream_bucket_make_writeable': '(resource $brigade): StreamBucket|null\nReturns a bucket object from the brigade to operate on',
'stream_bucket_new': '(resource $stream, string $buffer): StreamBucket\nCreate a new bucket for use on the current stream',
'stream_bucket_prepend': '(resource $brigade, StreamBucket $bucket): void\nPrepend bucket to brigade',
'stream_context_create': '(array|null $options = null, array|null $params = null): resource\nCreates a stream context',
'stream_context_get_default': '(array|null $options = null): resource\nRetrieve the default stream context',
'stream_context_get_options': '(resource $stream_or_context): array\nRetrieve options for a stream/wrapper/context',
'stream_context_get_params': '(resource $context): array\nRetrieves parameters from a context',
'stream_context_set_default': '(array $options): resource\nSet the default stream context',
'stream_context_set_option': '(resource $stream_or_context, string $wrapper, string $option, mixed $value): bool\nSets an option for a stream/wrapper/context',
'stream_context_set_options': '(resource $context, array $options): true\nSets options on the specified context',
'stream_context_set_params': '(resource $context, array $params): true\nSet parameters for a stream/wrapper/context',
'stream_copy_to_stream': '(resource $from, resource $to, int|null $length = null, int $offset = ?): int|false\nCopies data from one stream to another',
'stream_filter_append': '(resource $stream, string $filtername, int $read_write = ?, mixed $params = ?): resource\nAttach a filter to a stream',
'stream_filter_prepend': '(resource $stream, string $filtername, int $read_write = ?, mixed $params = ?): resource\nAttach a filter to a stream',
'stream_filter_register': '(string $filter_name, string $class): bool\nRegister a user defined stream filter',
'stream_filter_remove': '(resource $stream_filter): bool\nRemove a filter from a stream',
'stream_get_contents': '(resource $stream, int|null $length = null, int $offset = -1): string|false\nReads remainder of a stream into a string',
'stream_get_filters': '(): array\nRetrieve list of registered filters',
'stream_get_line': '(resource $stream, int $length, string $ending = ""): string|false\nGets line from stream resource up to a given delimiter',
'stream_get_meta_data': '(resource $stream): array\nRetrieves header/meta data from streams/file pointers',
'stream_get_transports': '(): array\nRetrieve list of registered socket transports',
'stream_get_wrappers': '(): array\nRetrieve list of registered streams',
'stream_is_local': '(resource|string $stream): bool\nChecks if a stream is a local stream',
'stream_isatty': '(resource $stream): bool\nCheck if a stream is a TTY',
'': '(int $notification_code, int $severity, string|null $message, int $message_code, int $bytes_transferred, int $bytes_max): void\nA callback function for the notification context parameter',
'stream_register_wrapper': 'Alias of stream_wrapper_register',
'stream_resolve_include_path': '(string $filename): string|false\nResolve filename against the include path',
'stream_select': '(array|null $read, array|null $write, array|null $except, int|null $seconds, int|null $microseconds = null): int|false\nRuns the equivalent of the select() system call on the given arrays of streams with a timeout specified by seconds and microseconds',
'stream_set_blocking': '(resource $stream, bool $enable): bool\nSet blocking/non-blocking mode on a stream',
'stream_set_chunk_size': '(resource $stream, int $size): int\nSet the stream chunk size',
'stream_set_read_buffer': '(resource $stream, int $size): int\nSet read file buffering on the given stream',
'stream_set_timeout': '(resource $stream, int $seconds, int $microseconds = ?): bool\nSet timeout period on a stream',
'stream_set_write_buffer': '(resource $stream, int $size): int\nSets write file buffering on the given stream',
'stream_socket_accept': '(resource $socket, float|null $timeout = null, string $peer_name = null): resource|false\nAccept a connection on a socket created by stream_socket_server',
'stream_socket_client': '(string $address, int $error_code = null, string $error_message = null, float|null $timeout = null, int $flags = STREAM_CLIENT_CONNECT, resource|null $context = null): resource|false\nOpen Internet or Unix domain socket connection',
'stream_socket_enable_crypto': '(resource $stream, bool $enable, int|null $crypto_method = null, resource|null $session_stream = null): int|bool\nTurns encryption on/off on an already connected socket',
'stream_socket_get_name': '(resource $socket, bool $remote): string|false\nRetrieve the name of the local or remote sockets',
'stream_socket_pair': '(int $domain, int $type, int $protocol): array|false\nCreates a pair of connected, indistinguishable socket streams',
'stream_socket_recvfrom': '(resource $socket, int $length, int $flags = ?, string|null $address = null): string|false\nReceives data from a socket, connected or not',
'stream_socket_sendto': '(resource $socket, string $data, int $flags = ?, string $address = ""): int|false\nSends a message to a socket, whether it is connected or not',
'stream_socket_server': '(string $address, int $error_code = null, string $error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, resource|null $context = null): resource|false\nCreate an Internet or Unix domain server socket',
'stream_socket_shutdown': '(resource $stream, int $mode): bool\nShutdown a full-duplex connection',
'stream_supports_lock': '(resource $stream): bool\nTells whether the stream supports locking',
'stream_wrapper_register': '(string $protocol, string $class, int $flags = ?): bool\nRegister a URL wrapper implemented as a PHP class',
'stream_wrapper_restore': '(string $protocol): bool\nRestores a previously unregistered built-in wrapper',
'stream_wrapper_unregister': '(string $protocol): bool\nUnregister a URL wrapper',
'php_user_filter::filter': '(resource $in, resource $out, int $consumed, bool $closing): int\nCalled when applying the filter',
'php_user_filter::onClose': '(): void\nCalled when closing the filter',
'php_user_filter::onCreate': '(): bool\nCalled when creating the filter',
'streamWrapper::dir_closedir': '(): bool\nClose directory handle',
'streamWrapper::dir_opendir': '(string $path, int $options): bool\nOpen directory handle',
'streamWrapper::dir_readdir': '(): string\nRead entry from directory handle',
'streamWrapper::dir_rewinddir': '(): bool\nRewind directory handle',
'streamWrapper::mkdir': '(string $path, int $mode, int $options): bool\nCreate a directory',
'streamWrapper::rename': '(string $path_from, string $path_to): bool\nRenames a file or directory',
'streamWrapper::rmdir': '(string $path, int $options): bool\nRemoves a directory',
'streamWrapper::stream_cast': '(int $cast_as): resource\nRetrieve the underlaying resource',
'streamWrapper::stream_close': '(): void\nClose a resource',
'streamWrapper::stream_eof': '(): bool\nTests for end-of-file on a file pointer',
'streamWrapper::stream_flush': '(): bool\nFlushes the output',
'streamWrapper::stream_lock': '(int $operation): bool\nAdvisory file locking',
'streamWrapper::stream_metadata': '(string $path, int $option, mixed $value): bool\nChange stream metadata',
'streamWrapper::stream_open': '(string $path, string $mode, int $options, string|null $opened_path): bool\nOpens file or URL',
'streamWrapper::stream_read': '(int $count): string|false\nRead from stream',
'streamWrapper::stream_seek': '(int $offset, int $whence): bool\nSeeks to specific location in a stream',
'streamWrapper::stream_set_option': '(int $option, int $arg1, int $arg2): bool\nChange stream options',
'streamWrapper::stream_stat': '(): array|false\nRetrieve information about a file resource',
'streamWrapper::stream_tell': '(): int\nRetrieve the current position of a stream',
'streamWrapper::stream_truncate': '(int $new_size): bool\nTruncate stream',
'streamWrapper::stream_write': '(string $data): int\nWrite to stream',
'streamWrapper::unlink': '(string $path): bool\nDelete a file',
'streamWrapper::url_stat': '(string $path, int $flags): array|false\nRetrieve information about a file',
'addcslashes': '(string $string, string $characters): string\nQuote string with slashes in a C style',
'addslashes': '(string $string): string\nQuote string with slashes',
'bin2hex': '(string $string): string\nConvert binary data into hexadecimal representation',
'chop': 'Alias of rtrim',
'chr': '(int $codepoint): string\nGenerate a single-byte string from a number',
'chunk_split': '(string $string, int $length = 76, string $separator = "\\r\\n"): string\nSplit a string into smaller chunks',
'convert_cyr_string': '(string $str, string $from, string $to): string\nConvert from one Cyrillic character set to another',
'convert_uudecode': '(string $string): string|false\nDecode a uuencoded string',
'convert_uuencode': '(string $string): string\nUuencode a string',
'count_chars': '(string $string, int $mode = ?): array|string\nReturn information about characters used in a string',
'crc32': '(string $string): int\nCalculates the crc32 polynomial of a string',
'crypt': '(string $string, string $salt): string\nOne-way string hashing',
'echo': '(string ...$expressions): void\nOutput one or more strings',
'explode': '(string $separator, string $string, int $limit = PHP_INT_MAX): array\nSplit a string by a string',
'fprintf': '(resource $stream, string $format, mixed ...$values): int\nWrite a formatted string to a stream',
'get_html_translation_table': '(int $table = HTML_SPECIALCHARS, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string $encoding = "UTF-8"): array\nReturns the translation table used by htmlspecialchars and htmlentities',
'hebrev': '(string $string, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text',
'hebrevc': '(string $hebrew_text, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text with newline conversion',
'hex2bin': '(string $string): string|false\nDecodes a hexadecimally encoded binary string',
'html_entity_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null): string\nConvert HTML entities to their corresponding characters',
'htmlentities': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null, bool $double_encode = true): string\nConvert all applicable characters to HTML entities',
'htmlspecialchars_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401): string\nConvert special HTML entities back to characters',
'htmlspecialchars': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null, bool $double_encode = true): string\nConvert special characters to HTML entities',
'implode': '(string $separator, array $array): string\nJoin array elements with a string',
'implode': '(array $array): string\nJoin array elements with a string',
'implode': '(array $array, string $separator): string\nJoin array elements with a string',
'join': 'Alias of implode',
'lcfirst': '(string $string): string\nMake a string\'s first character lowercase',
'levenshtein': '(string $string1, string $string2, int $insertion_cost = 1, int $replacement_cost = 1, int $deletion_cost = 1): int\nCalculate Levenshtein distance between two strings',
'localeconv': '(): array\nGet numeric formatting information',
'ltrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning of a string',
'md5_file': '(string $filename, bool $binary = false): string|false\nCalculates the md5 hash of a given file',
'md5': '(string $string, bool $binary = false): string\nCalculate the md5 hash of a string',
'metaphone': '(string $string, int $max_phonemes = ?): string\nCalculate the metaphone key of a string',
'money_format': '(string $format, float $number): string\nFormats a number as a currency string',
'nl_langinfo': '(int $item): string|false\nQuery language and locale information',
'nl2br': '(string $string, bool $use_xhtml = true): string\nInserts HTML line breaks before all newlines in a string',
'number_format': '(float $num, int $decimals = ?, string|null $decimal_separator = ".", string|null $thousands_separator = ","): string\nFormat a number with grouped thousands',
'ord': '(string $character): int\nConvert the first byte of a string to a value between 0 and 255',
'parse_str': '(string $string, array $result): void\nParses the string into variables',
'print': '(string $expression): int\nOutput a string',
'printf': '(string $format, mixed ...$values): int\nOutput a formatted string',
'quoted_printable_decode': '(string $string): string\nConvert a quoted-printable string to an 8 bit string',
'quoted_printable_encode': '(string $string): string\nConvert a 8 bit string to a quoted-printable string',
'quotemeta': '(string $string): string\nQuote meta characters',
'rtrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the end of a string',
'setlocale': '(int $category, string $locales, string ...$rest): string|false\nSet locale information',
'setlocale': '(int $category, array $locale_array): string|false\nSet locale information',
'sha1_file': '(string $filename, bool $binary = false): string|false\nCalculate the sha1 hash of a file',
'sha1': '(string $string, bool $binary = false): string\nCalculate the sha1 hash of a string',
'similar_text': '(string $string1, string $string2, float $percent = null): int\nCalculate the similarity between two strings',
'soundex': '(string $string): string\nCalculate the soundex key of a string',
'sprintf': '(string $format, mixed ...$values): string\nReturn a formatted string',
'sscanf': '(string $string, string $format, mixed ...$vars): array|int|null\nParses input from a string according to a format',
'str_contains': '(string $haystack, string $needle): bool\nDetermine if a string contains a given substring',
'str_decrement': '(string $string): string\nDecrement an alphanumeric string',
'str_ends_with': '(string $haystack, string $needle): bool\nChecks if a string ends with a given substring',
'str_getcsv': '(string $string, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array\nParse a CSV string into an array',
'str_increment': '(string $string): string\nIncrement an alphanumeric string',
'str_ireplace': '(array|string $search, array|string $replace, string|array $subject, int $count = null): string|array\nCase-insensitive version of str_replace',
'str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT): string\nPad a string to a certain length with another string',
'str_repeat': '(string $string, int $times): string\nRepeat a string',
'str_replace': '(array|string $search, array|string $replace, string|array $subject, int $count = null): string|array\nReplace all occurrences of the search string with the replacement string',
'str_rot13': '(string $string): string\nPerform the rot13 transform on a string',
'str_shuffle': '(string $string): string\nRandomly shuffles a string',
'str_split': '(string $string, int $length = 1): array\nConvert a string to an array',
'str_starts_with': '(string $haystack, string $needle): bool\nChecks if a string starts with a given substring',
'str_word_count': '(string $string, int $format = ?, string|null $characters = null): array|int\nReturn information about words used in a string',
'strcasecmp': '(string $string1, string $string2): int\nBinary safe case-insensitive string comparison',
'strchr': 'Alias of strstr',
'strcmp': '(string $string1, string $string2): int\nBinary safe string comparison',
'strcoll': '(string $string1, string $string2): int\nLocale based string comparison',
'strcspn': '(string $string, string $characters, int $offset = ?, int|null $length = null): int\nFind length of initial segment not matching mask',
'strip_tags': '(string $string, array|string|null $allowed_tags = null): string\nStrip HTML and PHP tags from a string',
'stripcslashes': '(string $string): string\nUn-quote string quoted with addcslashes',
'stripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a case-insensitive substring in a string',
'stripslashes': '(string $string): string\nUn-quotes a quoted string',
'stristr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nCase-insensitive strstr',
'strlen': '(string $string): int\nGet string length',
'strnatcasecmp': '(string $string1, string $string2): int\nCase insensitive string comparisons using a "natural order" algorithm',
'strnatcmp': '(string $string1, string $string2): int\nString comparisons using a "natural order" algorithm',
'strncasecmp': '(string $string1, string $string2, int $length): int\nBinary safe case-insensitive string comparison of the first n characters',
'strncmp': '(string $string1, string $string2, int $length): int\nBinary safe string comparison of the first n characters',
'strpbrk': '(string $string, string $characters): string|false\nSearch a string for any of a set of characters',
'strpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a substring in a string',
'strrchr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the last occurrence of a character in a string',
'strrev': '(string $string): string\nReverse a string',
'strripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a case-insensitive substring in a string',
'strrpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a substring in a string',
'strspn': '(string $string, string $characters, int $offset = ?, int|null $length = null): int\nFinds the length of the initial segment of a string consisting entirely of characters contained within a given mask',
'strstr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the first occurrence of a string',
'strtok': '(string $string, string $token): string|false\nTokenize string',
'strtok': '(string $token): string|false\nTokenize string',
'strtolower': '(string $string): string\nMake a string lowercase',
'strtoupper': '(string $string): string\nMake a string uppercase',
'strtr': '(string $string, string $from, string $to): string\nTranslate characters or replace substrings',
'strtr': '(string $string, array $replace_pairs): string\nTranslate characters or replace substrings',
'substr_compare': '(string $haystack, string $needle, int $offset, int|null $length = null, bool $case_insensitive = false): int\nBinary safe comparison of two strings from an offset, up to length characters',
'substr_count': '(string $haystack, string $needle, int $offset = ?, int|null $length = null): int\nCount the number of substring occurrences',
'substr_replace': '(array|string $string, array|string $replace, array|int $offset, array|int|null $length = null): string|array\nReplace text within a portion of a string',
'substr': '(string $string, int $offset, int|null $length = null): string\nReturn part of a string',
'trim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning and end of a string',
'ucfirst': '(string $string): string\nMake a string\'s first character uppercase',
'ucwords': '(string $string, string $separators = " \\t\\r\\n\\f\\v"): string\nUppercase the first character of each word in a string',
'utf8_decode': '(string $string): string\nConverts a string from UTF-8 to ISO-8859-1, replacing invalid or unrepresentable characters',
'utf8_encode': '(string $string): string\nConverts a string from ISO-8859-1 to UTF-8',
'vfprintf': '(resource $stream, string $format, array $values): int\nWrite a formatted string to a stream',
'vprintf': '(string $format, array $values): int\nOutput a formatted string',
'vsprintf': '(string $format, array $values): string\nReturn a formatted string',
'wordwrap': '(string $string, int $width = 75, string $break = "\\n", bool $cut_long_words = false): string\nWraps a string to a given number of characters',
'base64_decode': '(string $string, bool $strict = false): string|false\nDecodes data encoded with MIME base64',
'base64_encode': '(string $string): string\nEncodes data with MIME base64',
'get_headers': '(string $url, bool $associative = false, resource|null $context = null): array|false\nFetches all the headers sent by the server in response to an HTTP request',
'get_meta_tags': '(string $filename, bool $use_include_path = false): array|false\nExtracts all meta tag content attributes from a file and returns an array',
'http_build_query': '(array|object $data, string $numeric_prefix = "", string|null $arg_separator = null, int $encoding_type = PHP_QUERY_RFC1738): string\nGenerate URL-encoded query string',
'parse_url': '(string $url, int $component = -1): int|string|array|null|false\nParse a URL and return its components',
'rawurldecode': '(string $string): string\nDecode URL-encoded strings',
'rawurlencode': '(string $string): string\nURL-encode according to RFC 3986',
'urldecode': '(string $string): string\nDecodes URL-encoded string',
'urlencode': '(string $string): string\nURL-encodes string',
'boolval': '(mixed $value): bool\nGet the boolean value of a variable',
'debug_zval_dump': '(mixed $value, mixed ...$values): void\nDumps a string representation of an internal zval structure to output',
'doubleval': 'Alias of floatval',
'empty': '(mixed $var): bool\nDetermine whether a variable is empty',
'floatval': '(mixed $value): float\nGet float value of a variable',
'get_debug_type': '(mixed $value): string\nGets the type name of a variable in a way that is suitable for debugging',
'get_defined_vars': '(): array\nReturns an array of all defined variables',
'get_resource_id': '(resource $resource): int\nReturns an integer identifier for the given resource',
'get_resource_type': '(resource $resource): string\nReturns the resource type',
'gettype': '(mixed $value): string\nGet the type of a variable',
'intval': '(mixed $value, int $base = 10): int\nGet the integer value of a variable',
'is_array': '(mixed $value): bool\nFinds whether a variable is an array',
'is_bool': '(mixed $value): bool\nFinds out whether a variable is a boolean',
'is_callable': '(mixed $value, bool $syntax_only = false, string $callable_name = null): bool\nVerify that a value can be called as a function from the current scope',
'is_countable': '(mixed $value): bool\nVerify that the contents of a variable is a countable value',
'is_double': 'Alias of is_float',
'is_float': '(mixed $value): bool\nFinds whether the type of a variable is float',
'is_int': '(mixed $value): bool\nFind whether the type of a variable is integer',
'is_integer': 'Alias of is_int',
'is_iterable': '(mixed $value): bool\nVerify that the contents of a variable is an iterable value',
'is_long': 'Alias of is_int',
'is_null': '(mixed $value): bool\nFinds whether a variable is null',
'is_numeric': '(mixed $value): bool\nFinds whether a variable is a number or a numeric string',
'is_object': '(mixed $value): bool\nFinds whether a variable is an object',
'is_real': 'Alias of is_float',
'is_resource': '(mixed $value): bool\nFinds whether a variable is a resource',
'is_scalar': '(mixed $value): bool\nFinds whether a variable is a scalar',
'is_string': '(mixed $value): bool\nFind whether the type of a variable is string',
'isset': '(mixed $var, mixed ...$vars): bool\nDetermine if a variable is declared and is different than null',
'print_r': '(mixed $value, bool $return = false): string|true\nPrints human-readable information about a variable',
'serialize': '(mixed $value): string\nGenerates a storable representation of a value',
'settype': '(mixed $var, string $type): bool\nSet the type of a variable',
'strval': '(mixed $value): string\nGet string value of a variable',
'unserialize': '(string $data, array $options = []): mixed\nCreates a PHP value from a stored representation',
'unset': '(mixed $var, mixed ...$vars): void\nUnset a given variable',
'var_dump': '(mixed $value, mixed ...$values): void\nDumps information about a variable',
'var_export': '(mixed $value, bool $return = false): string|null\nOutputs or returns a parsable string representation of a variable',
'apache_child_terminate': '(): void\nTerminate apache process after this request',
'apache_get_modules': '(): array\nGet a list of loaded Apache modules',
'apache_get_version': '(): string|false\nFetch Apache version',
'apache_getenv': '(string $variable, bool $walk_to_top = false): string|false\nGet an Apache subprocess_env variable',
'apache_lookup_uri': '(string $filename): object|false\nPerform a partial request for the specified URI and return all info about it',
'apache_note': '(string $note_name, string|null $note_value = null): string|false\nGet and set apache request notes',
'apache_request_headers': '(): array\nFetch all HTTP request headers',
'apache_response_headers': '(): array\nFetch all HTTP response headers',
'apache_setenv': '(string $variable, string $value, bool $walk_to_top = false): bool\nSet an Apache subprocess_env variable',
'getallheaders': '(): array\nFetch all HTTP request headers',
'virtual': '(string $uri): bool\nPerform an Apache sub-request',
'BcMath\\Number::add': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nAdds an arbitrary precision number',
'BcMath\\Number::ceil': '(): BcMath\\Number\nRounds up an arbitrary precision number',
'BcMath\\Number::compare': '(BcMath\\Number|string|int $num, int|null $scale = null): int\nCompares two arbitrary precision numbers',
'BcMath\\Number::div': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nDivides by an arbitrary precision number',
'BcMath\\Number::divmod': '(BcMath\\Number|string|int $num, int|null $scale = null): array\nGets the quotient and modulus of an arbitrary precision number',
'BcMath\\Number::floor': '(): BcMath\\Number\nRounds down an arbitrary precision number',
'BcMath\\Number::mod': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nGets the modulus of an arbitrary precision number',
'BcMath\\Number::mul': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nMultiplies an arbitrary precision number',
'BcMath\\Number::pow': '(BcMath\\Number|string|int $exponent, int|null $scale = null): BcMath\\Number\nRaises an arbitrary precision number',
'BcMath\\Number::powmod': '(BcMath\\Number|string|int $exponent, BcMath\\Number|string|int $modulus, int|null $scale = null): BcMath\\Number\nRaises an arbitrary precision number, reduced by a specified modulus',
'BcMath\\Number::round': '(int $precision = ?, RoundingMode $mode = RoundingMode::HalfAwayFromZero): BcMath\\Number\nRounds an arbitrary precision number',
'BcMath\\Number::__serialize': '(): array\nSerializes a BcMath\\Number object',
'BcMath\\Number::sqrt': '(int|null $scale = null): BcMath\\Number\nGets the square root of an arbitrary precision number',
'BcMath\\Number::sub': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nSubtracts an arbitrary precision number',
'BcMath\\Number::__toString': '(): string\nConverts BcMath\\Number to string',
'BcMath\\Number::__unserialize': '(array $data): void\nDeserializes a data parameter into a BcMath\\Number object',
'bcadd': '(string $num1, string $num2, int|null $scale = null): string\nAdd two arbitrary precision numbers',
'bcceil': '(string $num): string\nRound up arbitrary precision number',
'bccomp': '(string $num1, string $num2, int|null $scale = null): int\nCompare two arbitrary precision numbers',
'bcdiv': '(string $num1, string $num2, int|null $scale = null): string\nDivide two arbitrary precision numbers',
'bcdivmod': '(string $num1, string $num2, int|null $scale = null): array\nGet the quotient and modulus of an arbitrary precision number',
'bcfloor': '(string $num): string\nRound down arbitrary precision number',
'bcmod': '(string $num1, string $num2, int|null $scale = null): string\nGet modulus of an arbitrary precision number',
'bcmul': '(string $num1, string $num2, int|null $scale = null): string\nMultiply two arbitrary precision numbers',
'bcpow': '(string $num, string $exponent, int|null $scale = null): string\nRaise an arbitrary precision number to another',
'bcpowmod': '(string $num, string $exponent, string $modulus, int|null $scale = null): string\nRaise an arbitrary precision number to another, reduced by a specified modulus',
'bcround': '(string $num, int $precision = ?, RoundingMode $mode = RoundingMode::HalfAwayFromZero): string\nRound arbitrary precision number',
'bcscale': '(int $scale): int\nSet or get default scale parameter for all bc math functions',
'bcscale': '(null $scale = null): int\nSet or get default scale parameter for all bc math functions',
'bcsqrt': '(string $num, int|null $scale = null): string\nGet the square root of an arbitrary precision number',
'bcsub': '(string $num1, string $num2, int|null $scale = null): string\nSubtract one arbitrary precision number from another',
'cal_days_in_month': '(int $calendar, int $month, int $year): int\nReturn the number of days in a month for a given year and calendar',
'cal_from_jd': '(int $julian_day, int $calendar): array\nConverts from Julian Day Count to a supported calendar',
'cal_info': '(int $calendar = -1): array\nReturns information about a particular calendar',
'cal_to_jd': '(int $calendar, int $month, int $day, int $year): int\nConverts from a supported calendar to Julian Day Count',
'easter_date': '(int|null $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet Unix timestamp for local midnight on Easter of a given year',
'easter_days': '(int|null $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet number of days after March 21 on which Easter falls for a given year',
'frenchtojd': '(int $month, int $day, int $year): int\nConverts a date from the French Republican Calendar to a Julian Day Count',
'gregoriantojd': '(int $month, int $day, int $year): int\nConverts a Gregorian date to Julian Day Count',
'jddayofweek': '(int $julian_day, int $mode = CAL_DOW_DAYNO): int|string\nReturns the day of the week',
'jdmonthname': '(int $julian_day, int $mode): string\nReturns a month name',
'jdtofrench': '(int $julian_day): string\nConverts a Julian Day Count to the French Republican Calendar',
'jdtogregorian': '(int $julian_day): string\nConverts Julian Day Count to Gregorian date',
'jdtojewish': '(int $julian_day, bool $hebrew = false, int $flags = ?): string\nConverts a Julian day count to a Jewish calendar date',
'jdtojulian': '(int $julian_day): string\nConverts a Julian Day Count to a Julian Calendar Date',
'jdtounix': '(int $julian_day): int\nConvert Julian Day to Unix timestamp',
'jewishtojd': '(int $month, int $day, int $year): int\nConverts a date in the Jewish Calendar to Julian Day Count',
'juliantojd': '(int $month, int $day, int $year): int\nConverts a Julian Calendar date to Julian Day Count',
'unixtojd': '(int|null $timestamp = null): int|false\nConvert Unix timestamp to Julian Day',
'COMPersistHelper::GetCurFileName': '(): string|false\nGet current filename',
'COMPersistHelper::GetMaxStreamSize': '(): int\nGet maximum stream size',
'COMPersistHelper::InitNew': '(): bool\nInitialize object to default state',
'COMPersistHelper::LoadFromFile': '(string $filename, int $flags = ?): bool\nLoad object from file',
'COMPersistHelper::LoadFromStream': '(resource $stream): bool\nLoad object from stream',
'COMPersistHelper::SaveToFile': '(string|null $filename, bool $remember = true): bool\nSave object to file',
'COMPersistHelper::SaveToStream': '(resource $stream): bool\nSave object to stream',
'com_create_guid': '(): string|false\nGenerate a globally unique identifier (GUID)',
'com_event_sink': '(variant $variant, object $sink_object, array|string|null $sink_interface = null): bool\nConnect events from a COM object to a PHP object',
'com_get_active_object': '(string $prog_id, int|null $codepage = null): variant\nReturns a handle to an already running instance of a COM object',
'com_load_typelib': '(string $typelib, bool $case_insensitive = true): bool\nLoads a Typelib',
'com_message_pump': '(int $timeout_milliseconds = ?): bool\nProcess COM messages, sleeping for up to timeoutms milliseconds',
'com_print_typeinfo': '(variant|string $variant, string|null $dispatch_interface = null, bool $display_sink = false): bool\nPrint out a PHP class definition for a dispatchable interface',
'variant_abs': '(mixed $value): variant\nReturns the absolute value of a variant',
'variant_add': '(mixed $left, mixed $right): variant\n"Adds" two variant values together and returns the result',
'variant_and': '(mixed $left, mixed $right): variant\nPerforms a bitwise AND operation between two variants',
'variant_cast': '(variant $variant, int $type): variant\nConvert a variant into a new variant object of another type',
'variant_cat': '(mixed $left, mixed $right): variant\nConcatenates two variant values together and returns the result',
'variant_cmp': '(mixed $left, mixed $right, int $locale_id = LOCALE_SYSTEM_DEFAULT, int $flags = ?): int\nCompares two variants',
'variant_date_from_timestamp': '(int $timestamp): variant\nReturns a variant date representation of a Unix timestamp',
'variant_date_to_timestamp': '(variant $variant): int|null\nConverts a variant date/time value to Unix timestamp',
'variant_div': '(mixed $left, mixed $right): variant\nReturns the result from dividing two variants',
'variant_eqv': '(mixed $left, mixed $right): variant\nPerforms a bitwise equivalence on two variants',
'variant_fix': '(mixed $value): variant\nReturns the integer portion of a variant',
'variant_get_type': '(variant $variant): int\nReturns the type of a variant object',
'variant_idiv': '(mixed $left, mixed $right): variant\nConverts variants to integers and then returns the result from dividing them',
'variant_imp': '(mixed $left, mixed $right): variant\nPerforms a bitwise implication on two variants',
'variant_int': '(mixed $value): variant\nReturns the integer portion of a variant',
'variant_mod': '(mixed $left, mixed $right): variant\nDivides two variants and returns only the remainder',
'variant_mul': '(mixed $left, mixed $right): variant\nMultiplies the values of the two variants',
'variant_neg': '(mixed $value): variant\nPerforms logical negation on a variant',
'variant_not': '(mixed $value): variant\nPerforms bitwise not negation on a variant',
'variant_or': '(mixed $left, mixed $right): variant\nPerforms a logical disjunction on two variants',
'variant_pow': '(mixed $left, mixed $right): variant\nReturns the result of performing the power function with two variants',
'variant_round': '(mixed $value, int $decimals): variant|null\nRounds a variant to the specified number of decimal places',
'variant_set_type': '(variant $variant, int $type): void\nConvert a variant into another type "in-place"',
'variant_set': '(variant $variant, mixed $value): void\nAssigns a new value for a variant object',
'variant_sub': '(mixed $left, mixed $right): variant\nSubtracts the value of the right variant from the left variant value',
'variant_xor': '(mixed $left, mixed $right): variant\nPerforms a logical exclusion on two variants',
'ctype_alnum': '(mixed $text): bool\nCheck for alphanumeric character(s)',
'ctype_alpha': '(mixed $text): bool\nCheck for alphabetic character(s)',
'ctype_cntrl': '(mixed $text): bool\nCheck for control character(s)',
'ctype_digit': '(mixed $text): bool\nCheck for numeric character(s)',
'ctype_graph': '(mixed $text): bool\nCheck for any printable character(s) except space',
'ctype_lower': '(mixed $text): bool\nCheck for lowercase character(s)',
'ctype_print': '(mixed $text): bool\nCheck for printable character(s)',
'ctype_punct': '(mixed $text): bool\nCheck for any printable character which is not whitespace or an alphanumeric character',
'ctype_space': '(mixed $text): bool\nCheck for whitespace character(s)',
'ctype_upper': '(mixed $text): bool\nCheck for uppercase character(s)',
'ctype_xdigit': '(mixed $text): bool\nCheck for character(s) representing a hexadecimal digit',
'dba_close': '(Dba\\Connection $dba): void\nClose a DBA database',
'dba_delete': '(string|array $key, Dba\\Connection $dba): bool\nDelete DBA entry specified by key',
'dba_exists': '(string|array $key, Dba\\Connection $dba): bool\nCheck whether key exists',
'dba_fetch': '(string|array $key, Dba\\Connection $dba, int $skip = ?): string|false\nFetch data specified by key',
'dba_fetch': '(string|array $key, int $skip, resource $dba): string\nFetch data specified by key',
'dba_firstkey': '(Dba\\Connection $dba): string|false\nFetch first key',
'dba_handlers': '(bool $full_info = false): array\nList all the handlers available',
'dba_insert': '(string|array $key, string $value, Dba\\Connection $dba): bool\nInsert entry',
'dba_key_split': '(string|false|null $key): array|false\nSplits a key in string representation into array representation',
'dba_list': '(): array\nList all open database files',
'dba_nextkey': '(Dba\\Connection $dba): string|false\nFetch next key',
'dba_open': '(string $path, string $mode, string|null $handler = null, int $permission = 0644, int $map_size = ?, int|null $flags = null): Dba\\Connection|false\nOpen database',
'dba_optimize': '(Dba\\Connection $dba): bool\nOptimize database',
'dba_popen': '(string $path, string $mode, string|null $handler = null, int $permission = 0644, int $map_size = ?, int|null $flags = null): Dba\\Connection|false\nOpen database persistently',
'dba_replace': '(string|array $key, string $value, Dba\\Connection $dba): bool\nReplace or insert entry',
'dba_sync': '(Dba\\Connection $dba): bool\nSynchronize database',
'exif_imagetype': '(string $filename): int|false\nDetermine the type of an image',
'exif_read_data': '(resource|string $file, string|null $required_sections = null, bool $as_arrays = false, bool $read_thumbnail = false): array|false\nReads the EXIF headers from an image file',
'exif_tagname': '(int $index): string|false\nGet the header name for an index',
'exif_thumbnail': '(resource|string $file, int $width = null, int $height = null, int $image_type = null): string|false\nRetrieve the embedded thumbnail of an image',
'read_exif_data': 'Alias of exif_read_data',
'FFI\\CType::getAlignment': '(): int\nDescription',
'FFI\\CType::getArrayElementType': '(): FFI\\CType\nDescription',
'FFI\\CType::getArrayLength': '(): int\nDescription',
'FFI\\CType::getAttributes': '(): int\nDescription',
'FFI\\CType::getEnumKind': '(): int\nDescription',
'FFI\\CType::getFuncABI': '(): int\nDescription',
'FFI\\CType::getFuncParameterCount': '(): int\nRetrieve the count of parameters of a function type',
'FFI\\CType::getFuncParameterType': '(int $index): FFI\\CType\nDescription',
'FFI\\CType::getFuncReturnType': '(): FFI\\CType\nDescription',
'FFI\\CType::getKind': '(): int\nDescription',
'FFI\\CType::getName': '(): string\nDescription',
'FFI\\CType::getPointerType': '(): FFI\\CType\nDescription',
'FFI\\CType::getSize': '(): int\nDescription',
'FFI\\CType::getStructFieldNames': '(): array\nDescription',
'FFI\\CType::getStructFieldOffset': '(string $name): int\nDescription',
'FFI\\CType::getStructFieldType': '(string $name): FFI\\CType\nDescription',
'FFI::addr': '(FFI\\CData $ptr): FFI\\CData\nCreates an unmanaged pointer to C data',
'FFI::alignof': '(FFI\\CData|FFI\\CType $ptr): int\nGets the alignment',
'FFI::arrayType': '(FFI\\CType $type, array $dimensions): FFI\\CType\nDynamically constructs a new C array type',
'FFI::cast': '(FFI\\CType|string $type, FFI\\CData|int|float|bool|null $ptr): FFI\\CData|null\nPerforms a C type cast',
'FFI::cdef': '(string $code = "", string|null $lib = null): FFI\nCreates a new FFI object',
'FFI::free': '(FFI\\CData $ptr): void\nReleases an unmanaged data structure',
'FFI::isNull': '(FFI\\CData $ptr): bool\nChecks whether a FFI\\CData is a null pointer',
'FFI::load': '(string $filename): FFI|null\nLoads C declarations from a C header file',
'FFI::memcmp': '(string|FFI\\CData $ptr1, string|FFI\\CData $ptr2, int $size): int\nCompares memory areas',
'FFI::memcpy': '(FFI\\CData $to, FFI\\CData|string $from, int $size): void\nCopies one memory area to another',
'FFI::memset': '(FFI\\CData $ptr, int $value, int $size): void\nFills a memory area',
'FFI::scope': '(string $name): FFI\nInstantiates an FFI object with C declarations parsed during preloading',
'FFI::sizeof': '(FFI\\CData|FFI\\CType $ptr): int\nGets the size of C data or types',
'FFI::string': '(FFI\\CData $ptr, int|null $size = null): string\nCreates a PHP string from a memory area',
'FFI::type': '(string $type): FFI\\CType|null\nCreates an FFI\\CType object from a C declaration',
'FFI::typeof': '(FFI\\CData $ptr): FFI\\CType\nGets the FFI\\CType of FFI\\CData',
'finfo::buffer': '(string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nAlias finfo_buffer()',
'finfo::file': '(string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nAlias finfo_file()',
'finfo::set_flags': '(int $flags): true\nAlias finfo_set_flags()',
'finfo_buffer': '(finfo $finfo, string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a string buffer',
'finfo::buffer': '(string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a string buffer',
'finfo_close': '(finfo $finfo): bool\nClose finfo instance',
'finfo_file': '(finfo $finfo, string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a file',
'finfo::file': '(string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a file',
'finfo_open': '(int $flags = FILEINFO_NONE, string|null $magic_database = null): finfo|false\nCreate a new finfo instance',
'finfo_set_flags': '(finfo $finfo, int $flags): true\nSet libmagic configuration options',
'finfo::set_flags': '(int $flags): true\nSet libmagic configuration options',
'mime_content_type': '(resource|string $filename): string|false\nDetect MIME Content-type for a file',
'filter_has_var': '(int $input_type, string $var_name): bool\nChecks if variable of specified type exists',
'filter_id': '(string $name): int|false\nReturns the filter ID belonging to a named filter',
'filter_input_array': '(int $type, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets external variables and optionally filters them',
'filter_input': '(int $type, string $var_name, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nGets a specific external variable by name and optionally filters it',
'filter_list': '(): array\nReturns a list of all supported filters',
'filter_var_array': '(array $array, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets multiple variables and optionally filters them',
'filter_var': '(mixed $value, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nFilters a variable with a specified filter',
'ftp_alloc': '(FTP\\Connection $ftp, int $size, string $response = null): bool\nAllocates space for a file to be uploaded',
'ftp_append': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY): bool\nAppend the contents of a file to another file on the FTP server',
'ftp_cdup': '(FTP\\Connection $ftp): bool\nChanges to the parent directory',
'ftp_chdir': '(FTP\\Connection $ftp, string $directory): bool\nChanges the current directory on a FTP server',
'ftp_chmod': '(FTP\\Connection $ftp, int $permissions, string $filename): int|false\nSet permissions on a file via FTP',
'ftp_close': '(FTP\\Connection $ftp): bool\nCloses an FTP connection',
'ftp_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens an FTP connection',
'ftp_delete': '(FTP\\Connection $ftp, string $filename): bool\nDeletes a file on the FTP server',
'ftp_exec': '(FTP\\Connection $ftp, string $command): bool\nRequests execution of a command on the FTP server',
'ftp_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server and saves to an open file',
'ftp_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads from an open file to the FTP server',
'ftp_get_option': '(FTP\\Connection $ftp, int $option): int|bool\nRetrieves various runtime behaviours of the current FTP connection',
'ftp_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server',
'ftp_login': '(FTP\\Connection $ftp, string $username, string $password): bool\nLogs in to an FTP connection',
'ftp_mdtm': '(FTP\\Connection $ftp, string $filename): int\nReturns the last modified time of the given file',
'ftp_mkdir': '(FTP\\Connection $ftp, string $directory): string|false\nCreates a directory',
'ftp_mlsd': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
'ftp_nb_continue': '(FTP\\Connection $ftp): int\nContinues retrieving/sending a file (non-blocking)',
'ftp_nb_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int\nRetrieves a file from the FTP server and writes it to an open file (non-blocking)',
'ftp_nb_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): int\nStores a file from an open file to the FTP server (non-blocking)',
'ftp_nb_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nRetrieves a file from the FTP server and writes it to a local file (non-blocking)',
'ftp_nb_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nStores a file on the FTP server (non-blocking)',
'ftp_nlist': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
'ftp_pasv': '(FTP\\Connection $ftp, bool $enable): bool\nTurns passive mode on or off',
'ftp_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads a file to the FTP server',
'ftp_pwd': '(FTP\\Connection $ftp): string|false\nReturns the current directory name',
'ftp_quit': 'Alias of ftp_close',
'ftp_raw': '(FTP\\Connection $ftp, string $command): array|null\nSends an arbitrary command to an FTP server',
'ftp_rawlist': '(FTP\\Connection $ftp, string $directory, bool $recursive = false): array|false\nReturns a detailed list of files in the given directory',
'ftp_rename': '(FTP\\Connection $ftp, string $from, string $to): bool\nRenames a file or a directory on the FTP server',
'ftp_rmdir': '(FTP\\Connection $ftp, string $directory): bool\nRemoves a directory',
'ftp_set_option': '(FTP\\Connection $ftp, int $option, int|bool $value): bool\nSet miscellaneous runtime FTP options',
'ftp_site': '(FTP\\Connection $ftp, string $command): bool\nSends a SITE command to the server',
'ftp_size': '(FTP\\Connection $ftp, string $filename): int\nReturns the size of the given file',
'ftp_ssl_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens a Secure SSL-FTP connection',
'ftp_systype': '(FTP\\Connection $ftp): string|false\nReturns the system type identifier of the remote FTP server',
'iconv_get_encoding': '(string $type = "all"): array|string|false\nRetrieve internal configuration variables of iconv extension',
'iconv_mime_decode_headers': '(string $headers, int $mode = ?, string|null $encoding = null): array|false\nDecodes multiple MIME header fields at once',
'iconv_mime_decode': '(string $string, int $mode = ?, string|null $encoding = null): string|false\nDecodes a MIME header field',
'iconv_mime_encode': '(string $field_name, string $field_value, array $options = []): string|false\nComposes a MIME header field',
'iconv_set_encoding': '(string $type, string $encoding): bool\nSet current setting for character encoding conversion',
'iconv_strlen': '(string $string, string|null $encoding = null): int|false\nReturns the character count of string',
'iconv_strpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of first occurrence of a needle within a haystack',
'iconv_strrpos': '(string $haystack, string $needle, string|null $encoding = null): int|false\nFinds the last occurrence of a needle within a haystack',
'iconv_substr': '(string $string, int $offset, int|null $length = null, string|null $encoding = null): string|false\nCut out part of a string',
'iconv': '(string $from_encoding, string $to_encoding, string $string): string|false\nConvert a string from one character encoding to another',
'ob_iconv_handler': '(string $contents, int $status): string\nConvert character encoding as output buffer handler',
'gd_info': '(): array\nRetrieve information about the currently installed GD library',
'getimagesize': '(string $filename, array $image_info = null): array|false\nGet the size of an image',
'getimagesizefromstring': '(string $string, array $image_info = null): array|false\nGet the size of an image from a string',
'image_type_to_extension': '(int $image_type, bool $include_dot = true): string|false\nGet file extension for image type',
'image_type_to_mime_type': '(int $image_type): string\nGet Mime-Type for image-type returned by getimagesize, exif_read_data, exif_thumbnail, exif_imagetype',
'image2wbmp': '(resource $image, string $filename = ?, int $foreground = ?): bool\ngd.image.output',
'imageaffine': '(GdImage $image, array $affine, array|null $clip = null): GdImage|false\nReturn an image containing the affine transformed src image, using an optional clipping area',
'imageaffinematrixconcat': '(array $matrix1, array $matrix2): array|false\nConcatenate two affine transformation matrices',
'imageaffinematrixget': '(int $type, array|float $options): array|false\nGet an affine transformation matrix',
'imagealphablending': '(GdImage $image, bool $enable): bool\nSet the blending mode for an image',
'imageantialias': '(GdImage $image, bool $enable): bool\nShould antialias functions be used or not',
'imagearc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color): bool\nDraws an arc',
'imageavif': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $speed = -1): bool\ngd.image.output',
'imagebmp': '(GdImage $image, resource|string|null $file = null, bool $compressed = true): bool\nOutput a BMP image to browser or file',
'imagechar': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): bool\nDraw a character horizontally',
'imagecharup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): bool\nDraw a character vertically',
'imagecolorallocate': '(GdImage $image, int $red, int $green, int $blue): int|false\nAllocate a color for an image',
'imagecolorallocatealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int|false\nAllocate a color for an image',
'imagecolorat': '(GdImage $image, int $x, int $y): int|false\nGet the index of the color of a pixel',
'imagecolorclosest': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the closest color to the specified color',
'imagecolorclosestalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the closest color to the specified color + alpha',
'imagecolorclosesthwb': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the color which has the hue, white and blackness',
'imagecolordeallocate': '(GdImage $image, int $color): bool\nDe-allocate a color for an image',
'imagecolorexact': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color',
'imagecolorexactalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha',
'imagecolormatch': '(GdImage $image1, GdImage $image2): bool\nMakes the colors of the palette version of an image more closely match the true color version',
'imagecolorresolve': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color or its closest possible alternative',
'imagecolorresolvealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha or its closest possible alternative',
'imagecolorset': '(GdImage $image, int $color, int $red, int $green, int $blue, int $alpha = ?): false|null\nSet the color for the specified palette index',
'imagecolorsforindex': '(GdImage $image, int $color): array\nGet the colors for an index',
'imagecolorstotal': '(GdImage $image): int\nFind out the number of colors in an image\'s palette',
'imagecolortransparent': '(GdImage $image, int|null $color = null): int\nDefine a color as transparent',
'imageconvolution': '(GdImage $image, array $matrix, float $divisor, float $offset): bool\nApply a 3x3 convolution matrix, using coefficient and offset',
'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\nCopy part of an image',
'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\nCopy and merge part of an image',
'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\nCopy and merge part of an image with gray scale',
'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\nCopy and resize part of an image with resampling',
'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\nCopy and resize part of an image',
'imagecreate': '(int $width, int $height): GdImage|false\nCreate a new palette based image',
'imagecreatefromavif': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefrombmp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromgd': '(string $filename): GdImage|false\nCreate a new image from GD file or URL',
'imagecreatefromgd2': '(string $filename): GdImage|false\nCreate a new image from GD2 file or URL',
'imagecreatefromgd2part': '(string $filename, int $x, int $y, int $width, int $height): GdImage|false\nCreate a new image from a given part of GD2 file or URL',
'imagecreatefromgif': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromjpeg': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefrompng': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromstring': '(string $data): GdImage|false\nCreate a new image from the image stream in the string',
'imagecreatefromtga': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromwbmp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromwebp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromxbm': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromxpm': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatetruecolor': '(int $width, int $height): GdImage|false\nCreate a new true color image',
'imagecrop': '(GdImage $image, array $rectangle): GdImage|false\nCrop an image to the given rectangle',
'imagecropauto': '(GdImage $image, int $mode = IMG_CROP_DEFAULT, float $threshold = 0.5, int $color = -1): GdImage|false\nCrop an image automatically using one of the available modes',
'imagedashedline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a dashed line',
'imagedestroy': '(GdImage $image): bool\nDestroy an image',
'imageellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool\nDraw an ellipse',
'imagefill': '(GdImage $image, int $x, int $y, int $color): bool\nFlood fill',
'imagefilledarc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color, int $style): bool\nDraw a partial arc and fill it',
'imagefilledellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool\nDraw a filled ellipse',
'imagefilledpolygon': '(GdImage $image, array $points, int $color): bool\nDraw a filled polygon',
'imagefilledpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraw a filled polygon',
'imagefilledrectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a filled rectangle',
'imagefilltoborder': '(GdImage $image, int $x, int $y, int $border_color, int $color): bool\nFlood fill to specific color',
'imagefilter': '(GdImage $image, int $filter, array|int|float|bool ...$args): bool\nApplies a filter to an image',
'imageflip': '(GdImage $image, int $mode): bool\nFlips an image using a given mode',
'imagefontheight': '(GdFont|int $font): int\nGet font height',
'imagefontwidth': '(GdFont|int $font): int\nGet font width',
'imageftbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using fonts via freetype2',
'imagefttext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using fonts using FreeType 2',
'imagegammacorrect': '(GdImage $image, float $input_gamma, float $output_gamma): bool\nApply a gamma correction to a GD image',
'imagegd': '(GdImage $image, string|null $file = null): bool\nOutput GD image to browser or file',
'imagegd2': '(GdImage $image, string|null $file = null, int $chunk_size = 128, int $mode = IMG_GD2_RAW): bool\nOutput GD2 image to browser or file',
'imagegetclip': '(GdImage $image): array\nGet the clipping rectangle',
'imagegetinterpolation': '(GdImage $image): int\nGet the interpolation method',
'imagegif': '(GdImage $image, resource|string|null $file = null): bool\ngd.image.output',
'imagegrabscreen': '(): GdImage|false\nCaptures the whole screen',
'imagegrabwindow': '(int $handle, bool $client_area = false): GdImage|false\nCaptures a window',
'imageinterlace': '(GdImage $image, bool|null $enable = null): bool\nEnable or disable interlace',
'imageistruecolor': '(GdImage $image): bool\nFinds whether an image is a truecolor image',
'imagejpeg': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\ngd.image.output',
'imagelayereffect': '(GdImage $image, int $effect): bool\nSet the alpha blending flag to use layering effects',
'imageline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a line',
'imageloadfont': '(string $filename): GdFont|false\nLoad a new font',
'imageopenpolygon': '(GdImage $image, array $points, int $color): bool\nDraws an open polygon',
'imageopenpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws an open polygon',
'imagepalettecopy': '(GdImage $dst, GdImage $src): void\nCopy the palette from one image to another',
'imagepalettetotruecolor': '(GdImage $image): bool\nConverts a palette based image to true color',
'imagepng': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $filters = -1): bool\nOutput a PNG image to either the browser or a file',
'imagepolygon': '(GdImage $image, array $points, int $color): bool\nDraws a polygon',
'imagepolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws a polygon',
'imagerectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a rectangle',
'imageresolution': '(GdImage $image, int|null $resolution_x = null, int|null $resolution_y = null): array|bool\nGet or set the resolution of the image',
'imagerotate': '(GdImage $image, float $angle, int $background_color): GdImage|false\nRotate an image with a given angle',
'imagesavealpha': '(GdImage $image, bool $enable): bool\nWhether to retain full alpha channel information when saving images',
'imagescale': '(GdImage $image, int $width, int $height = -1, int $mode = IMG_BILINEAR_FIXED): GdImage|false\nScale an image using the given new width and height',
'imagesetbrush': '(GdImage $image, GdImage $brush): bool\nSet the brush image for line drawing',
'imagesetclip': '(GdImage $image, int $x1, int $y1, int $x2, int $y2): bool\nSet the clipping rectangle',
'imagesetinterpolation': '(GdImage $image, int $method = IMG_BILINEAR_FIXED): bool\nSet the interpolation method',
'imagesetpixel': '(GdImage $image, int $x, int $y, int $color): bool\nSet a single pixel',
'imagesetstyle': '(GdImage $image, array $style): bool\nSet the style for line drawing',
'imagesetthickness': '(GdImage $image, int $thickness): bool\nSet the thickness for line drawing',
'imagesettile': '(GdImage $image, GdImage $tile): bool\nSet the tile image for filling',
'imagestring': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): bool\nDraw a string horizontally',
'imagestringup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): bool\nDraw a string vertically',
'imagesx': '(GdImage $image): int\nGet image width',
'imagesy': '(GdImage $image): int\nGet image height',
'imagetruecolortopalette': '(GdImage $image, bool $dither, int $num_colors): bool\nConvert a true color image to a palette image',
'imagettfbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using TrueType fonts',
'imagettftext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using TrueType fonts',
'imagetypes': '(): int\nReturn the image types supported by this PHP build',
'imagewbmp': '(GdImage $image, resource|string|null $file = null, int|null $foreground_color = null): bool\ngd.image.output',
'imagewebp': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\nOutput a WebP image to browser or file',
'imagexbm': '(GdImage $image, string|null $filename, int|null $foreground_color = null): bool\nOutput an XBM image to browser or file',
'iptcembed': '(string $iptc_data, string $filename, int $spool = ?): string|bool\nEmbeds binary IPTC data into a JPEG image',
'iptcparse': '(string $iptc_block): array|false\nParse a binary IPTC block into single tags',
'jpeg2wbmp': '(string $jpegname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert JPEG image file to WBMP image file',
'png2wbmp': '(string $pngname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert PNG image file to WBMP image file',
'Collator::asort': '(array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array maintaining index association',
'collator_asort': '(Collator $object, array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array maintaining index association',
'Collator::compare': '(string $string1, string $string2): int|false\nCompare two Unicode strings',
'collator_compare': '(Collator $object, string $string1, string $string2): int|false\nCompare two Unicode strings',
'Collator::create': '(string $locale): Collator|null\nCreate a collator',
'collator_create': '(string $locale): Collator|null\nCreate a collator',
'Collator::getAttribute': '(int $attribute): int|false\nGet collation attribute value',
'collator_get_attribute': '(Collator $object, int $attribute): int|false\nGet collation attribute value',
'Collator::getErrorCode': '(): int|false\nGet collator\'s last error code',
'collator_get_error_code': '(Collator $object): int|false\nGet collator\'s last error code',
'Collator::getErrorMessage': '(): string|false\nGet text for collator\'s last error code',
'collator_get_error_message': '(Collator $object): string|false\nGet text for collator\'s last error code',
'Collator::getLocale': '(int $type): string|false\nGet the locale name of the collator',
'collator_get_locale': '(Collator $object, int $type): string|false\nGet the locale name of the collator',
'Collator::getSortKey': '(string $string): string|false\nGet sorting key for a string',
'collator_get_sort_key': '(Collator $object, string $string): string|false\nGet sorting key for a string',
'Collator::getStrength': '(): int\nGet current collation strength',
'collator_get_strength': '(Collator $object): int\nGet current collation strength',
'Collator::setAttribute': '(int $attribute, int $value): bool\nSet collation attribute',
'collator_set_attribute': '(Collator $object, int $attribute, int $value): bool\nSet collation attribute',
'Collator::setStrength': '(int $strength): true\nSet collation strength',
'collator_set_strength': '(Collator $object, int $strength): true\nSet collation strength',
'Collator::sortWithSortKeys': '(array $array): bool\nSort array using specified collator and sort keys',
'collator_sort_with_sort_keys': '(Collator $object, array $array): bool\nSort array using specified collator and sort keys',
'Collator::sort': '(array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array using specified collator',
'collator_sort': '(Collator $object, array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array using specified collator',
'IntlDateFormatter::create': '(string|null $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, string|null $pattern = null): IntlDateFormatter|null\nCreate a date formatter',
'datefmt_create': '(string|null $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, string|null $pattern = null): IntlDateFormatter|null\nCreate a date formatter',
'IntlDateFormatter::format': '(IntlCalendar|DateTimeInterface|array|string|int|float $datetime): string|false\nFormat the date/time value as a string',
'datefmt_format': '(IntlDateFormatter $formatter, IntlCalendar|DateTimeInterface|array|string|int|float $datetime): string|false\nFormat the date/time value as a string',
'IntlDateFormatter::formatObject': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, string|null $locale = null): string|false\nFormats an object',
'datefmt_format_object': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, string|null $locale = null): string|false\nFormats an object',
'IntlDateFormatter::getCalendar': '(): int|false\nGet the calendar type used for the IntlDateFormatter',
'datefmt_get_calendar': '(IntlDateFormatter $formatter): int|false\nGet the calendar type used for the IntlDateFormatter',
'IntlDateFormatter::getDateType': '(): int|false\nGet the datetype used for the IntlDateFormatter',
'datefmt_get_datetype': '(IntlDateFormatter $formatter): int|false\nGet the datetype used for the IntlDateFormatter',
'IntlDateFormatter::getErrorCode': '(): int\nGet the error code from last operation',
'datefmt_get_error_code': '(IntlDateFormatter $formatter): int\nGet the error code from last operation',
'IntlDateFormatter::getErrorMessage': '(): string\nGet the error text from the last operation',
'datefmt_get_error_message': '(IntlDateFormatter $formatter): string\nGet the error text from the last operation',
'IntlDateFormatter::getLocale': '(int $type = ULOC_ACTUAL_LOCALE): string|false\nGet the locale used by formatter',
'datefmt_get_locale': '(IntlDateFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet the locale used by formatter',
'IntlDateFormatter::getPattern': '(): string|false\nGet the pattern used for the IntlDateFormatter',
'datefmt_get_pattern': '(IntlDateFormatter $formatter): string|false\nGet the pattern used for the IntlDateFormatter',
'IntlDateFormatter::getTimeType': '(): int|false\nGet the timetype used for the IntlDateFormatter',
'datefmt_get_timetype': '(IntlDateFormatter $formatter): int|false\nGet the timetype used for the IntlDateFormatter',
'IntlDateFormatter::getTimeZoneId': '(): string|false\nGet the timezone-id used for the IntlDateFormatter',
'datefmt_get_timezone_id': '(IntlDateFormatter $formatter): string|false\nGet the timezone-id used for the IntlDateFormatter',
'IntlDateFormatter::getCalendarObject': '(): IntlCalendar|false|null\nGet copy of formatterʼs calendar object',
'datefmt_get_calendar_object': '(IntlDateFormatter $formatter): IntlCalendar|false|null\nGet copy of formatterʼs calendar object',
'IntlDateFormatter::getTimeZone': '(): IntlTimeZone|false\nGet formatterʼs timezone',
'datefmt_get_timezone': '(IntlDateFormatter $formatter): IntlTimeZone|false\nGet formatterʼs timezone',
'IntlDateFormatter::isLenient': '(): bool\nGet the lenient used for the IntlDateFormatter',
'datefmt_is_lenient': '(IntlDateFormatter $formatter): bool\nGet the lenient used for the IntlDateFormatter',
'IntlDateFormatter::localtime': '(string $string, int $offset = null): array|false\nParse string to a field-based time value',
'datefmt_localtime': '(IntlDateFormatter $formatter, string $string, int $offset = null): array|false\nParse string to a field-based time value',
'IntlDateFormatter::parse': '(string $string, int $offset = null): int|float|false\nParse string to a timestamp value',
'datefmt_parse': '(IntlDateFormatter $formatter, string $string, int $offset = null): int|float|false\nParse string to a timestamp value',
'IntlDateFormatter::setCalendar': '(IntlCalendar|int|null $calendar): bool\nSets the calendar type used by the formatter',
'datefmt_set_calendar': '(IntlDateFormatter $formatter, IntlCalendar|int|null $calendar): bool\nSets the calendar type used by the formatter',
'IntlDateFormatter::setLenient': '(bool $lenient): void\nSet the leniency of the parser',
'datefmt_set_lenient': '(IntlDateFormatter $formatter, bool $lenient): void\nSet the leniency of the parser',
'IntlDateFormatter::setPattern': '(string $pattern): bool\nSet the pattern used for the IntlDateFormatter',
'datefmt_set_pattern': '(IntlDateFormatter $formatter, string $pattern): bool\nSet the pattern used for the IntlDateFormatter',
'IntlDateFormatter::setTimeZone': '(IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSets formatterʼs timezone',
'datefmt_set_timezone': '(IntlDateFormatter $formatter, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSets formatterʼs timezone',
'intl_error_name': '(int $errorCode): string\nGet symbolic name for a given error code',
'intl_get_error_code': '(): int\nGet the last error code',
'intl_get_error_message': '(): string\nGet description of the last error',
'intl_is_failure': '(int $errorCode): bool\nCheck whether the given error code indicates failure',
'grapheme_extract': '(string $haystack, int $size, int $type = GRAPHEME_EXTR_COUNT, int $offset = ?, int $next = null): string|false\nFunction to extract a sequence of default grapheme clusters from a text buffer, which must be encoded in UTF-8',
'grapheme_str_split': '(string $string, int $length = 1): array|false\nSplit a string into an array',
'grapheme_stripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of first occurrence of a case-insensitive string',
'grapheme_stristr': '(string $haystack, string $needle, bool $beforeNeedle = false): string|false\nReturns part of haystack string from the first occurrence of case-insensitive needle to the end of haystack',
'grapheme_strlen': '(string $string): int|false|null\nGet string length in grapheme units',
'grapheme_strpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of first occurrence of a string',
'grapheme_strripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of last occurrence of a case-insensitive string',
'grapheme_strrpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of last occurrence of a string',
'grapheme_strstr': '(string $haystack, string $needle, bool $beforeNeedle = false): string|false\nReturns part of haystack string from the first occurrence of needle to the end of haystack',
'grapheme_substr': '(string $string, int $offset, int|null $length = null): string|false\nReturn part of a string',
'idn_to_ascii': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array $idna_info = null): string|false\nConvert domain name to IDNA ASCII form',
'idn_to_utf8': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array $idna_info = null): string|false\nConvert domain name from IDNA ASCII to Unicode',
'IntlBreakIterator::createCharacterInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for boundaries of combining character sequences',
'IntlBreakIterator::createCodePointInstance': '(): IntlCodePointBreakIterator\nCreate break iterator for boundaries of code points',
'IntlBreakIterator::createLineInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for logically possible line breaks',
'IntlBreakIterator::createSentenceInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for sentence breaks',
'IntlBreakIterator::createTitleInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for title-casing breaks',
'IntlBreakIterator::createWordInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for word breaks',
'IntlBreakIterator::current': '(): int\nGet index of current position',
'IntlBreakIterator::first': '(): int\nSet position to the first character in the text',
'IntlBreakIterator::following': '(int $offset): int\nAdvance the iterator to the first boundary following specified offset',
'IntlBreakIterator::getErrorCode': '(): int\nGet last error code on the object',
'intl_get_error_code': '(): int\nGet last error code on the object',
'IntlBreakIterator::getErrorMessage': '(): string\nGet last error message on the object',
'intl_get_error_message': '(): string\nGet last error message on the object',
'IntlBreakIterator::getLocale': '(int $type): string|false\nGet the locale associated with the object',
'IntlBreakIterator::getPartsIterator': '(string $type = IntlPartsIterator::KEY_SEQUENTIAL): IntlPartsIterator\nCreate iterator for navigating fragments between boundaries',
'IntlBreakIterator::getText': '(): string|null\nGet the text being scanned',
'IntlBreakIterator::isBoundary': '(int $offset): bool\nTell whether an offset is a boundaryʼs offset',
'IntlBreakIterator::last': '(): int\nSet the iterator position to index beyond the last character',
'IntlBreakIterator::next': '(int|null $offset = null): int\nAdvance the iterator the next boundary',
'IntlBreakIterator::preceding': '(int $offset): int\nSet the iterator position to the first boundary before an offset',
'IntlBreakIterator::previous': '(): int\nSet the iterator position to the boundary immediately before the current',
'IntlBreakIterator::setText': '(string $text): bool\nSet the text being scanned',
'IntlCalendar::add': '(int $field, int $value): bool\nAdd a (signed) amount of time to a field',
'intlcal_add': '(IntlCalendar $calendar, int $field, int $value): bool\nAdd a (signed) amount of time to a field',
'IntlCalendar::after': '(IntlCalendar $other): bool\nWhether this objectʼs time is after that of the passed object',
'intlcal_after': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is after that of the passed object',
'IntlCalendar::before': '(IntlCalendar $other): bool\nWhether this objectʼs time is before that of the passed object',
'intlcal_before': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is before that of the passed object',
'IntlCalendar::clear': '(int|null $field = null): true\nClear a field or all fields',
'intlcal_clear': '(IntlCalendar $calendar, int|null $field = null): true\nClear a field or all fields',
'IntlCalendar::createInstance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, string|null $locale = null): IntlCalendar|null\nCreate a new IntlCalendar',
'intlcal_create_instance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, string|null $locale = null): IntlCalendar|null\nCreate a new IntlCalendar',
'IntlCalendar::equals': '(IntlCalendar $other): bool\nCompare time of two IntlCalendar objects for equality',
'intlcal_equals': '(IntlCalendar $calendar, IntlCalendar $other): bool\nCompare time of two IntlCalendar objects for equality',
'IntlCalendar::fieldDifference': '(float $timestamp, int $field): int|false\nCalculate difference between given time and this objectʼs time',
'intlcal_field_difference': '(IntlCalendar $calendar, float $timestamp, int $field): int|false\nCalculate difference between given time and this objectʼs time',
'IntlCalendar::fromDateTime': '(DateTime|string $datetime, string|null $locale = null): IntlCalendar|null\nCreate an IntlCalendar from a DateTime object or string',
'intlcal_from_date_time': '(DateTime|string $datetime, string|null $locale = null): IntlCalendar|null\nCreate an IntlCalendar from a DateTime object or string',
'IntlCalendar::get': '(int $field): int|false\nGet the value for a field',
'intlcal_get': '(IntlCalendar $calendar, int $field): int|false\nGet the value for a field',
'IntlCalendar::getActualMaximum': '(int $field): int|false\nThe maximum value for a field, considering the objectʼs current time',
'intlcal_get_actual_maximum': '(IntlCalendar $calendar, int $field): int|false\nThe maximum value for a field, considering the objectʼs current time',
'IntlCalendar::getActualMinimum': '(int $field): int|false\nThe minimum value for a field, considering the objectʼs current time',
'intlcal_get_actual_minimum': '(IntlCalendar $calendar, int $field): int|false\nThe minimum value for a field, considering the objectʼs current time',
'IntlCalendar::getAvailableLocales': '(): array\nGet array of locales for which there is data',
'intlcal_get_available_locales': '(): array\nGet array of locales for which there is data',
'IntlCalendar::getDayOfWeekType': '(int $dayOfWeek): int|false\nTell whether a day is a weekday, weekend or a day that has a transition between the two',
'intlcal_get_day_of_week_type': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nTell whether a day is a weekday, weekend or a day that has a transition between the two',
'IntlCalendar::getErrorCode': '(): int|false\nGet last error code on the object',
'intlcal_get_error_code': '(IntlCalendar $calendar): int|false\nGet last error code on the object',
'IntlCalendar::getErrorMessage': '(): string|false\nGet last error message on the object',
'intlcal_get_error_message': '(IntlCalendar $calendar): string|false\nGet last error message on the object',
'IntlCalendar::getFirstDayOfWeek': '(): int|false\nGet the first day of the week for the calendarʼs locale',
'intlcal_get_first_day_of_week': '(IntlCalendar $calendar): int|false\nGet the first day of the week for the calendarʼs locale',
'IntlCalendar::getGreatestMinimum': '(int $field): int|false\nGet the largest local minimum value for a field',
'intlcal_get_greatest_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the largest local minimum value for a field',
'IntlCalendar::getKeywordValuesForLocale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
'intlcal_get_keyword_values_for_locale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
'IntlCalendar::getLeastMaximum': '(int $field): int|false\nGet the smallest local maximum for a field',
'intlcal_get_least_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the smallest local maximum for a field',
'IntlCalendar::getLocale': '(int $type): string|false\nGet the locale associated with the object',
'intlcal_get_locale': '(IntlCalendar $calendar, int $type): string|false\nGet the locale associated with the object',
'IntlCalendar::getMaximum': '(int $field): int|false\nGet the global maximum value for a field',
'intlcal_get_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the global maximum value for a field',
'IntlCalendar::getMinimalDaysInFirstWeek': '(): int|false\nGet minimal number of days the first week in a year or month can have',
'intlcal_get_minimal_days_in_first_week': '(IntlCalendar $calendar): int|false\nGet minimal number of days the first week in a year or month can have',
'IntlCalendar::getMinimum': '(int $field): int|false\nGet the global minimum value for a field',
'intlcal_get_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the global minimum value for a field',
'IntlCalendar::getNow': '(): float\nGet number representing the current time',
'intlcal_get_now': '(): float\nGet number representing the current time',
'IntlCalendar::getRepeatedWallTimeOption': '(): int\nGet behavior for handling repeating wall time',
'intlcal_get_repeated_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling repeating wall time',
'IntlCalendar::getSkippedWallTimeOption': '(): int\nGet behavior for handling skipped wall time',
'intlcal_get_skipped_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling skipped wall time',
'IntlCalendar::getTime': '(): float|false\nGet time currently represented by the object',
'intlcal_get_time': '(IntlCalendar $calendar): float|false\nGet time currently represented by the object',
'IntlCalendar::getTimeZone': '(): IntlTimeZone|false\nGet the objectʼs timezone',
'intlcal_get_time_zone': '(IntlCalendar $calendar): IntlTimeZone|false\nGet the objectʼs timezone',
'IntlCalendar::getType': '(): string\nGet the calendar type',
'intlcal_get_type': '(IntlCalendar $calendar): string\nGet the calendar type',
'IntlCalendar::getWeekendTransition': '(int $dayOfWeek): int|false\nGet time of the day at which weekend begins or ends',
'intlcal_get_weekend_transition': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nGet time of the day at which weekend begins or ends',
'IntlCalendar::inDaylightTime': '(): bool\nWhether the objectʼs time is in Daylight Savings Time',
'intlcal_in_daylight_time': '(IntlCalendar $calendar): bool\nWhether the objectʼs time is in Daylight Savings Time',
'IntlCalendar::isEquivalentTo': '(IntlCalendar $other): bool\nWhether another calendar is equal but for a different time',
'intlcal_is_equivalent_to': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether another calendar is equal but for a different time',
'IntlCalendar::isLenient': '(): bool\nWhether date/time interpretation is in lenient mode',
'intlcal_is_lenient': '(IntlCalendar $calendar): bool\nWhether date/time interpretation is in lenient mode',
'IntlCalendar::isSet': '(int $field): bool\nWhether a field is set',
'intlcal_is_set': '(IntlCalendar $calendar, int $field): bool\nWhether a field is set',
'IntlCalendar::isWeekend': '(float|null $timestamp = null): bool\nWhether a certain date/time is in the weekend',
'intlcal_is_weekend': '(IntlCalendar $calendar, float|null $timestamp = null): bool\nWhether a certain date/time is in the weekend',
'IntlCalendar::roll': '(int $field, int|bool $value): bool\nAdd value to field without carrying into more significant fields',
'intlcal_roll': '(IntlCalendar $calendar, int $field, int|bool $value): bool\nAdd value to field without carrying into more significant fields',
'IntlCalendar::set': '(int $field, int $value): true\nSet a time field or several common fields at once',
'IntlCalendar::set': '(int $year, int $month, int $dayOfMonth = NULL, int $hour = NULL, int $minute = NULL, int $second = NULL): true\nSet a time field or several common fields at once',
'intlcal_set': '(IntlCalendar $cal, int $field, int $value): true\nSet a time field or several common fields at once',
'intlcal_set': '(IntlCalendar $cal, int $year, int $month, int $dayOfMonth = NULL, int $hour = NULL, int $minute = NULL, int $second = NULL): bool\nSet a time field or several common fields at once',
'IntlCalendar::setDate': '(int $year, int $month, int $dayOfMonth): void\nSet a date fields',
'IntlCalendar::setDateTime': '(int $year, int $month, int $dayOfMonth, int $hour, int $minute, int|null $second = null): void\nSet a date and time fields',
'IntlCalendar::setFirstDayOfWeek': '(int $dayOfWeek): true\nSet the day on which the week is deemed to start',
'intlcal_set_first_day_of_week': '(IntlCalendar $calendar, int $dayOfWeek): true\nSet the day on which the week is deemed to start',
'IntlCalendar::setLenient': '(bool $lenient): true\nSet whether date/time interpretation is to be lenient',
'intlcal_set_lenient': '(IntlCalendar $calendar, bool $lenient): true\nSet whether date/time interpretation is to be lenient',
'IntlCalendar::setMinimalDaysInFirstWeek': '(int $days): true\nSet minimal number of days the first week in a year or month can have',
'intlcal_set_minimal_days_in_first_week': '(IntlCalendar $calendar, int $days): true\nSet minimal number of days the first week in a year or month can have',
'IntlCalendar::setRepeatedWallTimeOption': '(int $option): true\nSet behavior for handling repeating wall times at negative timezone offset transitions',
'intlcal_set_repeated_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling repeating wall times at negative timezone offset transitions',
'IntlCalendar::setSkippedWallTimeOption': '(int $option): true\nSet behavior for handling skipped wall times at positive timezone offset transitions',
'intlcal_set_skipped_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling skipped wall times at positive timezone offset transitions',
'IntlCalendar::setTime': '(float $timestamp): bool\nSet the calendar time in milliseconds since the epoch',
'intlcal_set_time': '(IntlCalendar $calendar, float $timestamp): bool\nSet the calendar time in milliseconds since the epoch',
'IntlCalendar::setTimeZone': '(IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSet the timezone used by this calendar',
'intlcal_set_time_zone': '(IntlCalendar $calendar, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSet the timezone used by this calendar',
'IntlCalendar::toDateTime': '(): DateTime|false\nConvert an IntlCalendar into a DateTime object',
'intlcal_to_date_time': '(IntlCalendar $calendar): DateTime|false\nConvert an IntlCalendar into a DateTime object',
'IntlChar::charAge': '(int|string $codepoint): array|null\nGet the "age" of the code point',
'IntlChar::charDigitValue': '(int|string $codepoint): int|null\nGet the decimal digit value of a decimal digit character',
'IntlChar::charDirection': '(int|string $codepoint): int|null\nGet bidirectional category value for a code point',
'IntlChar::charFromName': '(string $name, int $type = IntlChar::UNICODE_CHAR_NAME): int|null\nFind Unicode character by name and return its code point value',
'IntlChar::charMirror': '(int|string $codepoint): int|string|null\nGet the "mirror-image" character for a code point',
'IntlChar::charName': '(int|string $codepoint, int $type = IntlChar::UNICODE_CHAR_NAME): string|null\nRetrieve the name of a Unicode character',
'IntlChar::charType': '(int|string $codepoint): int|null\nGet the general category value for a code point',
'IntlChar::chr': '(int|string $codepoint): string|null\nReturn Unicode character by code point value',
'IntlChar::digit': '(int|string $codepoint, int $base = 10): int|false|null\nGet the decimal digit value of a code point for a given radix',
'IntlChar::enumCharNames': '(int|string $start, int|string $end, callable $callback, int $type = IntlChar::UNICODE_CHAR_NAME): bool\nEnumerate all assigned Unicode characters within a range',
'IntlChar::enumCharTypes': '(callable $callback): void\nEnumerate all code points with their Unicode general categories',
'IntlChar::foldCase': '(int|string $codepoint, int $options = IntlChar::FOLD_CASE_DEFAULT): int|string|null\nPerform case folding on a code point',
'IntlChar::forDigit': '(int $digit, int $base = 10): int\nGet character representation for a given digit and radix',
'IntlChar::getBidiPairedBracket': '(int|string $codepoint): int|string|null\nGet the paired bracket character for a code point',
'IntlChar::getBlockCode': '(int|string $codepoint): int|null\nGet the Unicode allocation block containing a code point',
'IntlChar::getCombiningClass': '(int|string $codepoint): int|null\nGet the combining class of a code point',
'IntlChar::getFC_NFKC_Closure': '(int|string $codepoint): string|false|null\nGet the FC_NFKC_Closure property for a code point',
'IntlChar::getIntPropertyMaxValue': '(int $property): int\nGet the max value for a Unicode property',
'IntlChar::getIntPropertyMinValue': '(int $property): int\nGet the min value for a Unicode property',
'IntlChar::getIntPropertyValue': '(int|string $codepoint, int $property): int|null\nGet the value for a Unicode property for a code point',
'IntlChar::getNumericValue': '(int|string $codepoint): float|null\nGet the numeric value for a Unicode code point',
'IntlChar::getPropertyEnum': '(string $alias): int\nGet the property constant value for a given property name',
'IntlChar::getPropertyName': '(int $property, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property',
'IntlChar::getPropertyValueEnum': '(int $property, string $name): int\nGet the property value for a given value name',
'IntlChar::getPropertyValueName': '(int $property, int $value, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property value',
'IntlChar::getUnicodeVersion': '(): array\nGet the Unicode version',
'IntlChar::hasBinaryProperty': '(int|string $codepoint, int $property): bool|null\nCheck a binary Unicode property for a code point',
'IntlChar::isalnum': '(int|string $codepoint): bool|null\nCheck if code point is an alphanumeric character',
'IntlChar::isalpha': '(int|string $codepoint): bool|null\nCheck if code point is a letter character',
'IntlChar::isbase': '(int|string $codepoint): bool|null\nCheck if code point is a base character',
'IntlChar::isblank': '(int|string $codepoint): bool|null\nCheck if code point is a "blank" or "horizontal space" character',
'IntlChar::iscntrl': '(int|string $codepoint): bool|null\nCheck if code point is a control character',
'IntlChar::isdefined': '(int|string $codepoint): bool|null\nCheck whether the code point is defined',
'IntlChar::isdigit': '(int|string $codepoint): bool|null\nCheck if code point is a digit character',
'IntlChar::isgraph': '(int|string $codepoint): bool|null\nCheck if code point is a graphic character',
'IntlChar::isIDIgnorable': '(int|string $codepoint): bool|null\nCheck if code point is an ignorable character',
'IntlChar::isIDPart': '(int|string $codepoint): bool|null\nCheck if code point is permissible in an identifier',
'IntlChar::isIDStart': '(int|string $codepoint): bool|null\nCheck if code point is permissible as the first character in an identifier',
'IntlChar::isISOControl': '(int|string $codepoint): bool|null\nCheck if code point is an ISO control code',
'IntlChar::isJavaIDPart': '(int|string $codepoint): bool|null\nCheck if code point is permissible in a Java identifier',
'IntlChar::isJavaIDStart': '(int|string $codepoint): bool|null\nCheck if code point is permissible as the first character in a Java identifier',
'IntlChar::isJavaSpaceChar': '(int|string $codepoint): bool|null\nCheck if code point is a space character according to Java',
'IntlChar::islower': '(int|string $codepoint): bool|null\nCheck if code point is a lowercase letter',
'IntlChar::isMirrored': '(int|string $codepoint): bool|null\nCheck if code point has the Bidi_Mirrored property',
'IntlChar::isprint': '(int|string $codepoint): bool|null\nCheck if code point is a printable character',
'IntlChar::ispunct': '(int|string $codepoint): bool|null\nCheck if code point is punctuation character',
'IntlChar::isspace': '(int|string $codepoint): bool|null\nCheck if code point is a space character',
'IntlChar::istitle': '(int|string $codepoint): bool|null\nCheck if code point is a titlecase letter',
'IntlChar::isUAlphabetic': '(int|string $codepoint): bool|null\nCheck if code point has the Alphabetic Unicode property',
'IntlChar::isULowercase': '(int|string $codepoint): bool|null\nCheck if code point has the Lowercase Unicode property',
'IntlChar::isupper': '(int|string $codepoint): bool|null\nCheck if code point has the general category "Lu" (uppercase letter)',
'IntlChar::isUUppercase': '(int|string $codepoint): bool|null\nCheck if code point has the Uppercase Unicode property',
'IntlChar::isUWhiteSpace': '(int|string $codepoint): bool|null\nCheck if code point has the White_Space Unicode property',
'IntlChar::isWhitespace': '(int|string $codepoint): bool|null\nCheck if code point is a whitespace character according to ICU',
'IntlChar::isxdigit': '(int|string $codepoint): bool|null\nCheck if code point is a hexadecimal digit',
'IntlChar::ord': '(int|string $character): int|null\nReturn Unicode code point value of character',
'IntlChar::tolower': '(int|string $codepoint): int|string|null\nMake Unicode character lowercase',
'IntlChar::totitle': '(int|string $codepoint): int|string|null\nMake Unicode character titlecase',
'IntlChar::toupper': '(int|string $codepoint): int|string|null\nMake Unicode character uppercase',
'IntlCodePointBreakIterator::getLastCodePoint': '(): int\nGet last code point passed over after advancing or receding the iterator',
'IntlDatePatternGenerator::create': '(string|null $locale = null): IntlDatePatternGenerator|null\nCreates a new IntlDatePatternGenerator instance',
'IntlDatePatternGenerator::getBestPattern': '(string $skeleton): string|false\nDetermines the most suitable date/time format',
'IntlGregorianCalendar::createFromDate': '(int $year, int $month, int $dayOfMonth): static\nCreate a new IntlGregorianCalendar instance from date',
'IntlGregorianCalendar::createFromDateTime': '(int $year, int $month, int $dayOfMonth, int $hour, int $minute, int|null $second = null): static\nCreate a new IntlGregorianCalendar instance from date and time',
'IntlGregorianCalendar::getGregorianChange': '(): float\nGet the Gregorian Calendar change date',
'IntlGregorianCalendar::isLeapYear': '(int $year): bool\nDetermine if the given year is a leap year',
'IntlGregorianCalendar::setGregorianChange': '(float $timestamp): bool\nSet the Gregorian Calendar the change date',
'IntlIterator::current': '(): mixed\nGet the current element',
'IntlIterator::key': '(): mixed\nGet the current key',
'IntlIterator::next': '(): void\nMove forward to the next element',
'IntlIterator::rewind': '(): void\nRewind the iterator to the first element',
'IntlIterator::valid': '(): bool\nCheck if current position is valid',
'IntlPartsIterator::getBreakIterator': '(): IntlBreakIterator\nGet IntlBreakIterator backing this parts iterator',
'IntlRuleBasedBreakIterator::getBinaryRules': '(): string|false\nGet the binary form of compiled rules',
'IntlRuleBasedBreakIterator::getRules': '(): string|false\nGet the rule set used to create this object',
'IntlRuleBasedBreakIterator::getRuleStatus': '(): int\nGet the largest status value from the break rules that determined the current break position',
'IntlRuleBasedBreakIterator::getRuleStatusVec': '(): array|false\nGet the status values from the break rules that determined the current break position',
'IntlTimeZone::countEquivalentIDs': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
'intltz_count_equivalent_ids': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
'IntlTimeZone::createDefault': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
'intltz_create_default': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
'IntlTimeZone::createEnumeration': '(IntlTimeZone|string|int|float|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
'intltz_create_enumeration': '(IntlTimeZone|string|int|float|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
'IntlTimeZone::createTimeZone': '(string $timezoneId): IntlTimeZone|null\nCreate a timezone object for the given ID',
'intltz_create_time_zone': '(string $timezoneId): IntlTimeZone|null\nCreate a timezone object for the given ID',
'IntlTimeZone::createTimeZoneIDEnumeration': '(int $type, string|null $region = null, int|null $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
'intltz_create_time_zone_id_enumeration': '(int $type, string|null $region = null, int|null $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
'IntlTimeZone::fromDateTimeZone': '(DateTimeZone $timezone): IntlTimeZone|null\nCreate a timezone object from DateTimeZone',
'intltz_from_date_time_zone': '(DateTimeZone $timezone): IntlTimeZone|null\nCreate a timezone object from DateTimeZone',
'IntlTimeZone::getCanonicalID': '(string $timezoneId, bool $isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
'intltz_get_canonical_id': '(string $timezoneId, bool $isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
'IntlTimeZone::getDisplayName': '(bool $dst = false, int $style = IntlTimeZone::DISPLAY_LONG, string|null $locale = null): string|false\nGet a name of this time zone suitable for presentation to the user',
'intltz_get_display_name': '(IntlTimeZone $timezone, bool $dst = false, int $style = IntlTimeZone::DISPLAY_LONG, string|null $locale = null): string|false\nGet a name of this time zone suitable for presentation to the user',
'IntlTimeZone::getDSTSavings': '(): int\nGet the amount of time to be added to local standard time to get local wall clock time',
'intltz_get_dst_savings': '(IntlTimeZone $timezone): int\nGet the amount of time to be added to local standard time to get local wall clock time',
'IntlTimeZone::getEquivalentID': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
'intltz_get_equivalent_id': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
'IntlTimeZone::getErrorCode': '(): int|false\nGet last error code on the object',
'intltz_get_error_code': '(IntlTimeZone $timezone): int|false\nGet last error code on the object',
'IntlTimeZone::getErrorMessage': '(): string|false\nGet last error message on the object',
'intltz_get_error_message': '(IntlTimeZone $timezone): string|false\nGet last error message on the object',
'IntlTimeZone::getGMT': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
'intltz_get_gmt': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
'IntlTimeZone::getID': '(): string|false\nGet timezone ID',
'intltz_get_id': '(IntlTimeZone $timezone): string|false\nGet timezone ID',
'IntlTimeZone::getIDForWindowsID': '(string $timezoneId, string|null $region = null): string|false\nTranslate a Windows timezone into a system timezone',
'intltz_get_id_for_windows_id': '(string $timezoneId, string|null $region = null): string|false\nTranslate a Windows timezone into a system timezone',
'IntlTimeZone::getOffset': '(float $timestamp, bool $local, int $rawOffset, int $dstOffset): bool\nGet the time zone raw and GMT offset for the given moment in time',
'intltz_get_offset': '(IntlTimeZone $timezone, float $timestamp, bool $local, int $rawOffset, int $dstOffset): bool\nGet the time zone raw and GMT offset for the given moment in time',
'IntlTimeZone::getRawOffset': '(): int\nGet the raw GMT offset (before taking daylight savings time into account',
'intltz_get_raw_offset': '(IntlTimeZone $timezone): int\nGet the raw GMT offset (before taking daylight savings time into account',
'IntlTimeZone::getRegion': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
'intltz_get_region': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
'IntlTimeZone::getTZDataVersion': '(): string|false\nGet the timezone data version currently used by ICU',
'intltz_get_tz_data_version': '(): string|false\nGet the timezone data version currently used by ICU',
'IntlTimeZone::getUnknown': '(): IntlTimeZone\nGet the "unknown" time zone',
'intltz_get_unknown': '(): IntlTimeZone\nGet the "unknown" time zone',
'IntlTimeZone::getWindowsID': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
'intltz_get_windows_id': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
'IntlTimeZone::hasSameRules': '(IntlTimeZone $other): bool\nCheck if this zone has the same rules and offset as another zone',
'intltz_has_same_rules': '(IntlTimeZone $timezone, IntlTimeZone $other): bool\nCheck if this zone has the same rules and offset as another zone',
'IntlTimeZone::toDateTimeZone': '(): DateTimeZone|false\nConvert to DateTimeZone object',
'intltz_to_date_time_zone': '(IntlTimeZone $timezone): DateTimeZone|false\nConvert to DateTimeZone object',
'IntlTimeZone::useDaylightTime': '(): bool\nCheck if this time zone uses daylight savings time',
'intltz_use_daylight_time': '(IntlTimeZone $timezone): bool\nCheck if this time zone uses daylight savings time',
'Locale::acceptFromHttp': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
'locale_accept_from_http': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
'Locale::canonicalize': '(string $locale): string|null\nCanonicalize the locale string',
'Locale::composeLocale': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
'locale_compose': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
'Locale::filterMatches': '(string $languageTag, string $locale, bool $canonicalize = false): bool|null\nChecks if a language tag filter matches with locale',
'locale_filter_matches': '(string $languageTag, string $locale, bool $canonicalize = false): bool|null\nChecks if a language tag filter matches with locale',
'Locale::getAllVariants': '(string $locale): array|null\nGets the variants for the input locale',
'locale_get_all_variants': '(string $locale): array|null\nGets the variants for the input locale',
'Locale::getDefault': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
'locale_get_default': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
'Locale::getDisplayLanguage': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
'locale_get_display_language': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
'Locale::getDisplayName': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
'locale_get_display_name': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
'Locale::getDisplayRegion': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
'locale_get_display_region': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
'Locale::getDisplayScript': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
'locale_get_display_script': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
'Locale::getDisplayVariant': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
'locale_get_display_variant': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
'Locale::getKeywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
'locale_get_keywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
'Locale::getPrimaryLanguage': '(string $locale): string|null\nGets the primary language for the input locale',
'locale_get_primary_language': '(string $locale): string|null\nGets the primary language for the input locale',
'Locale::getRegion': '(string $locale): string|null\nGets the region for the input locale',
'locale_get_region': '(string $locale): string|null\nGets the region for the input locale',
'Locale::getScript': '(string $locale): string|null\nGets the script for the input locale',
'locale_get_script': '(string $locale): string|null\nGets the script for the input locale',
'Locale::lookup': '(array $languageTag, string $locale, bool $canonicalize = false, string|null $defaultLocale = null): string|null\nSearches the language tag list for the best match to the language',
'locale_lookup': '(array $languageTag, string $locale, bool $canonicalize = false, string|null $defaultLocale = null): string|null\nSearches the language tag list for the best match to the language',
'Locale::parseLocale': '(string $locale): array|null\nReturns a key-value array of locale ID subtag elements',
'locale_parse': '(string $locale): array|null\nReturns a key-value array of locale ID subtag elements',
'Locale::setDefault': '(string $locale): true\nSets the default runtime locale',
'locale_set_default': '(string $locale): true\nSets the default runtime locale',
'MessageFormatter::create': '(string $locale, string $pattern): MessageFormatter|null\nConstructs a new Message Formatter',
'msgfmt_create': '(string $locale, string $pattern): MessageFormatter|null\nConstructs a new Message Formatter',
'MessageFormatter::formatMessage': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
'msgfmt_format_message': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
'MessageFormatter::format': '(array $values): string|false\nFormat the message',
'msgfmt_format': '(MessageFormatter $formatter, array $values): string|false\nFormat the message',
'MessageFormatter::getErrorCode': '(): int\nGet the error code from last operation',
'msgfmt_get_error_code': '(MessageFormatter $formatter): int\nGet the error code from last operation',
'MessageFormatter::getErrorMessage': '(): string\nGet the error text from the last operation',
'msgfmt_get_error_message': '(MessageFormatter $formatter): string\nGet the error text from the last operation',
'MessageFormatter::getLocale': '(): string\nGet the locale for which the formatter was created',
'msgfmt_get_locale': '(MessageFormatter $formatter): string\nGet the locale for which the formatter was created',
'MessageFormatter::getPattern': '(): string|false\nGet the pattern used by the formatter',
'msgfmt_get_pattern': '(MessageFormatter $formatter): string|false\nGet the pattern used by the formatter',
'MessageFormatter::parseMessage': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
'msgfmt_parse_message': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
'MessageFormatter::parse': '(string $string): array|false\nParse input string according to pattern',
'msgfmt_parse': '(MessageFormatter $formatter, string $string): array|false\nParse input string according to pattern',
'MessageFormatter::setPattern': '(string $pattern): bool\nSet the pattern used by the formatter',
'msgfmt_set_pattern': '(MessageFormatter $formatter, string $pattern): bool\nSet the pattern used by the formatter',
'Normalizer::getRawDecomposition': '(string $string, int $form = Normalizer::FORM_C): string|null\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
'normalizer_get_raw_decomposition': '(string $string, int $form = Normalizer::FORM_C): string|null\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
'Normalizer::isNormalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
'normalizer_is_normalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
'Normalizer::normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
'normalizer_normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
'NumberFormatter::create': '(string $locale, int $style, string|null $pattern = null): NumberFormatter|null\nCreate a number formatter',
'numfmt_create': '(string $locale, int $style, string|null $pattern = null): NumberFormatter|null\nCreate a number formatter',
'NumberFormatter::formatCurrency': '(float $amount, string $currency): string|false\nFormat a currency value',
'numfmt_format_currency': '(NumberFormatter $formatter, float $amount, string $currency): string|false\nFormat a currency value',
'NumberFormatter::format': '(int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false\nFormat a number',
'numfmt_format': '(NumberFormatter $formatter, int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false\nFormat a number',
'NumberFormatter::getAttribute': '(int $attribute): int|float|false\nGet an attribute',
'numfmt_get_attribute': '(NumberFormatter $formatter, int $attribute): int|float|false\nGet an attribute',
'NumberFormatter::getErrorCode': '(): int\nGet formatter\'s last error code',
'numfmt_get_error_code': '(NumberFormatter $formatter): int\nGet formatter\'s last error code',
'NumberFormatter::getErrorMessage': '(): string\nGet formatter\'s last error message',
'numfmt_get_error_message': '(NumberFormatter $formatter): string\nGet formatter\'s last error message',
'NumberFormatter::getLocale': '(int $type = ULOC_ACTUAL_LOCALE): string|false\nGet formatter locale',
'numfmt_get_locale': '(NumberFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet formatter locale',
'NumberFormatter::getPattern': '(): string|false\nGet formatter pattern',
'numfmt_get_pattern': '(NumberFormatter $formatter): string|false\nGet formatter pattern',
'NumberFormatter::getSymbol': '(int $symbol): string|false\nGet a symbol value',
'numfmt_get_symbol': '(NumberFormatter $formatter, int $symbol): string|false\nGet a symbol value',
'NumberFormatter::getTextAttribute': '(int $attribute): string|false\nGet a text attribute',
'numfmt_get_text_attribute': '(NumberFormatter $formatter, int $attribute): string|false\nGet a text attribute',
'NumberFormatter::parseCurrency': '(string $string, string $currency, int $offset = null): float|false\nParse a currency number',
'numfmt_parse_currency': '(NumberFormatter $formatter, string $string, string $currency, int $offset = null): float|false\nParse a currency number',
'NumberFormatter::parse': '(string $string, int $type = NumberFormatter::TYPE_DOUBLE, int $offset = null): int|float|false\nParse a number',
'numfmt_parse': '(NumberFormatter $formatter, string $string, int $type = NumberFormatter::TYPE_DOUBLE, int $offset = null): int|float|false\nParse a number',
'NumberFormatter::setAttribute': '(int $attribute, int|float $value): bool\nSet an attribute',
'numfmt_set_attribute': '(NumberFormatter $formatter, int $attribute, int|float $value): bool\nSet an attribute',
'NumberFormatter::setPattern': '(string $pattern): bool\nSet formatter pattern',
'numfmt_set_pattern': '(NumberFormatter $formatter, string $pattern): bool\nSet formatter pattern',
'NumberFormatter::setSymbol': '(int $symbol, string $value): bool\nSet a symbol value',
'numfmt_set_symbol': '(NumberFormatter $formatter, int $symbol, string $value): bool\nSet a symbol value',
'NumberFormatter::setTextAttribute': '(int $attribute, string $value): bool\nSet a text attribute',
'numfmt_set_text_attribute': '(NumberFormatter $formatter, int $attribute, string $value): bool\nSet a text attribute',
'ResourceBundle::count': '(): int\nGet number of elements in the bundle',
'resourcebundle_count': '(ResourceBundle $bundle): int\nGet number of elements in the bundle',
'ResourceBundle::create': '(string|null $locale, string|null $bundle, bool $fallback = true): ResourceBundle|null\nCreate a resource bundle',
'resourcebundle_create': '(string|null $locale, string|null $bundle, bool $fallback = true): ResourceBundle|null\nCreate a resource bundle',
'ResourceBundle::getErrorCode': '(): int\nGet bundle\'s last error code',
'resourcebundle_get_error_code': '(ResourceBundle $bundle): int\nGet bundle\'s last error code',
'ResourceBundle::getErrorMessage': '(): string\nGet bundle\'s last error message',
'resourcebundle_get_error_message': '(ResourceBundle $bundle): string\nGet bundle\'s last error message',
'ResourceBundle::get': '(string|int $index, bool $fallback = true): mixed\nGet data from the bundle',
'resourcebundle_get': '(ResourceBundle $bundle, string|int $index, bool $fallback = true): mixed\nGet data from the bundle',
'ResourceBundle::getLocales': '(string $bundle): array|false\nGet supported locales',
'resourcebundle_locales': '(string $bundle): array|false\nGet supported locales',
'Spoofchecker::areConfusable': '(string $string1, string $string2, int $errorCode = null): bool\nChecks if given strings can be confused',
'Spoofchecker::isSuspicious': '(string $string, int $errorCode = null): bool\nChecks if a given text contains any suspicious characters',
'Spoofchecker::setAllowedLocales': '(string $locales): void\nLocales to use when running checks',
'Spoofchecker::setChecks': '(int $checks): void\nSet the checks to run',
'Spoofchecker::setRestrictionLevel': '(int $level): void\nSet the restriction level',
'Transliterator::create': '(string $id, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate a transliterator',
'transliterator_create': '(string $id, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate a transliterator',
'Transliterator::createFromRules': '(string $rules, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate transliterator from rules',
'transliterator_create_from_rules': '(string $rules, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate transliterator from rules',
'Transliterator::createInverse': '(): Transliterator|null\nCreate an inverse transliterator',
'transliterator_create_inverse': '(Transliterator $transliterator): Transliterator|null\nCreate an inverse transliterator',
'Transliterator::getErrorCode': '(): int|false\nGet last error code',
'transliterator_get_error_code': '(Transliterator $transliterator): int|false\nGet last error code',
'Transliterator::getErrorMessage': '(): string|false\nGet last error message',
'transliterator_get_error_message': '(Transliterator $transliterator): string|false\nGet last error message',
'Transliterator::listIDs': '(): array|false\nGet transliterator IDs',
'transliterator_list_ids': '(): array|false\nGet transliterator IDs',
'Transliterator::transliterate': '(string $string, int $start = ?, int $end = -1): string|false\nTransliterate a string',
'transliterator_transliterate': '(Transliterator|string $transliterator, string $string, int $start = ?, int $end = -1): string|false\nTransliterate a string',
'UConverter::convert': '(string $str, bool $reverse = false): string|false\nConvert string from one charset to another',
'UConverter::fromUCallback': '(int $reason, array $source, int $codePoint, int $error): string|int|array|null\nDefault "from" callback function',
'UConverter::getAliases': '(string $name): array|false|null\nGet the aliases of the given name',
'UConverter::getAvailable': '(): array\nGet the available canonical converter names',
'UConverter::getDestinationEncoding': '(): string|false|null\nGet the destination encoding',
'UConverter::getDestinationType': '(): int|false|null\nGet the destination converter type',
'UConverter::getErrorCode': '(): int\nGet last error code on the object',
'UConverter::getErrorMessage': '(): string|null\nGet last error message on the object',
'UConverter::getSourceEncoding': '(): string|false|null\nGet the source encoding',
'UConverter::getSourceType': '(): int|false|null\nGet the source converter type',
'UConverter::getStandards': '(): array|null\nGet standards associated to converter names',
'UConverter::getSubstChars': '(): string|false|null\nGet substitution chars',
'UConverter::reasonText': '(int $reason): string\nGet string representation of the callback reason',
'UConverter::setDestinationEncoding': '(string $encoding): bool\nSet the destination encoding',
'UConverter::setSourceEncoding': '(string $encoding): bool\nSet the source encoding',
'UConverter::setSubstChars': '(string $chars): bool\nSet the substitution chars',
'UConverter::toUCallback': '(int $reason, string $source, string $codeUnits, int $error): string|int|array|null\nDefault "to" callback function',
'UConverter::transcode': '(string $str, string $toEncoding, string $fromEncoding, array|null $options = null): string|false\nConvert a string from one character encoding to another',
'mb_check_encoding': '(array|string|null $value = null, string|null $encoding = null): bool\nCheck if strings are valid for the specified encoding',
'mb_chr': '(int $codepoint, string|null $encoding = null): string|false\nReturn character by Unicode code point value',
'mb_convert_case': '(string $string, int $mode, string|null $encoding = null): string\nPerform case folding on a string',
'mb_convert_encoding': '(array|string $string, string $to_encoding, array|string|null $from_encoding = null): array|string|false\nConvert a string from one character encoding to another',
'mb_convert_kana': '(string $string, string $mode = "KV", string|null $encoding = null): string\nConvert "kana" one from another ("zen-kaku", "han-kaku" and more)',
'mb_convert_variables': '(string $to_encoding, array|string $from_encoding, mixed $var, mixed ...$vars): string|false\nConvert character code in variable(s)',
'mb_decode_mimeheader': '(string $string): string\nDecode string in MIME header field',
'mb_decode_numericentity': '(string $string, array $map, string|null $encoding = null): string\nDecode HTML numeric string reference to character',
'mb_detect_encoding': '(string $string, array|string|null $encodings = null, bool $strict = false): string|false\nDetect character encoding',
'mb_detect_order': '(array|string|null $encoding = null): array|bool\nSet/Get character encoding detection order',
'mb_encode_mimeheader': '(string $string, string|null $charset = null, string|null $transfer_encoding = null, string $newline = "\\r\\n", int $indent = ?): string\nEncode string for MIME header',
'mb_encode_numericentity': '(string $string, array $map, string|null $encoding = null, bool $hex = false): string\nEncode character to HTML numeric string reference',
'mb_encoding_aliases': '(string $encoding): array\nGet aliases of a known encoding type',
'mb_ereg_match': '(string $pattern, string $string, string|null $options = null): bool\nRegular expression match for multibyte string',
'mb_ereg_replace_callback': '(string $pattern, callable $callback, string $string, string|null $options = null): string|false|null\nPerform a regular expression search and replace with multibyte support using a callback',
'mb_ereg_replace': '(string $pattern, string $replacement, string $string, string|null $options = null): string|false|null\nReplace regular expression with multibyte support',
'mb_ereg_search_getpos': '(): int\nReturns start point for next regular expression match',
'mb_ereg_search_getregs': '(): array|false\nRetrieve the result from the last multibyte regular expression match',
'mb_ereg_search_init': '(string $string, string|null $pattern = null, string|null $options = null): bool\nSetup string and regular expression for a multibyte regular expression match',
'mb_ereg_search_pos': '(string|null $pattern = null, string|null $options = null): array|false\nReturns position and length of a matched part of the multibyte regular expression for a predefined multibyte string',
'mb_ereg_search_regs': '(string|null $pattern = null, string|null $options = null): array|false\nReturns the matched part of a multibyte regular expression',
'mb_ereg_search_setpos': '(int $offset): bool\nSet start point of next regular expression match',
'mb_ereg_search': '(string|null $pattern = null, string|null $options = null): bool\nMultibyte regular expression match for predefined multibyte string',
'mb_ereg': '(string $pattern, string $string, array $matches = null): bool\nRegular expression match with multibyte support',
'mb_eregi_replace': '(string $pattern, string $replacement, string $string, string|null $options = null): string|false|null\nReplace regular expression with multibyte support ignoring case',
'mb_eregi': '(string $pattern, string $string, array $matches = null): bool\nRegular expression match ignoring case with multibyte support',
'mb_get_info': '(string $type = "all"): array|string|int|false|null\nGet internal settings of mbstring',
'mb_http_input': '(string|null $type = null): array|string|false\nDetect HTTP input character encoding',
'mb_http_output': '(string|null $encoding = null): string|bool\nSet/Get HTTP output character encoding',
'mb_internal_encoding': '(string|null $encoding = null): string|bool\nSet/Get internal character encoding',
'mb_language': '(string|null $language = null): string|bool\nSet/Get current language',
'mb_lcfirst': '(string $string, string|null $encoding = null): string\nMake a string\'s first character lowercase',
'mb_list_encodings': '(): array\nReturns an array of all supported encodings',
'mb_ltrim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the beginning of a string',
'mb_ord': '(string $string, string|null $encoding = null): int|false\nGet Unicode code point of character',
'mb_output_handler': '(string $string, int $status): string\nCallback function converts character encoding in output buffer',
'mb_parse_str': '(string $string, array $result): bool\nParse GET/POST/COOKIE data and set global variable',
'mb_preferred_mime_name': '(string $encoding): string|false\nGet MIME charset string',
'mb_regex_encoding': '(string|null $encoding = null): string|bool\nSet/Get character encoding for multibyte regex',
'mb_regex_set_options': '(string|null $options = null): string\nSet/Get the default options for mbregex functions',
'mb_rtrim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the end of a string',
'mb_scrub': '(string $string, string|null $encoding = null): string\nReplace ill-formed byte sequences with the substitute character',
'mb_send_mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], string|null $additional_params = null): bool\nSend encoded mail',
'mb_split': '(string $pattern, string $string, int $limit = -1): array|false\nSplit multibyte string using regular expression',
'mb_str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT, string|null $encoding = null): string\nPad a multibyte string to a certain length with another multibyte string',
'mb_str_split': '(string $string, int $length = 1, string|null $encoding = null): array\nGiven a multibyte string, return an array of its characters',
'mb_strcut': '(string $string, int $start, int|null $length = null, string|null $encoding = null): string\nGet part of string',
'mb_strimwidth': '(string $string, int $start, int $width, string $trim_marker = "", string|null $encoding = null): string\nGet truncated string with specified width',
'mb_stripos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of first occurrence of a string within another, case insensitive',
'mb_stristr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds first occurrence of a string within another, case insensitive',
'mb_strlen': '(string $string, string|null $encoding = null): int\nGet string length',
'mb_strpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFind position of first occurrence of string in a string',
'mb_strrchr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds the last occurrence of a character in a string within another',
'mb_strrichr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds the last occurrence of a character in a string within another, case insensitive',
'mb_strripos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of last occurrence of a string within another, case insensitive',
'mb_strrpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFind position of last occurrence of a string in a string',
'mb_strstr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds first occurrence of a string within another',
'mb_strtolower': '(string $string, string|null $encoding = null): string\nMake a string lowercase',
'mb_strtoupper': '(string $string, string|null $encoding = null): string\nMake a string uppercase',
'mb_strwidth': '(string $string, string|null $encoding = null): int\nReturn width of string',
'mb_substitute_character': '(string|int|null $substitute_character = null): string|int|bool\nSet/Get substitution character',
'mb_substr_count': '(string $haystack, string $needle, string|null $encoding = null): int\nCount the number of substring occurrences',
'mb_substr': '(string $string, int $start, int|null $length = null, string|null $encoding = null): string\nGet part of string',
'mb_trim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the beginning and end of a string',
'mb_ucfirst': '(string $string, string|null $encoding = null): string\nMake a string\'s first character uppercase',
'mhash_count': '(): int\nGets the highest available hash ID',
'mhash_get_block_size': '(int $algo): int|false\nGets the block size of the specified hash',
'mhash_get_hash_name': '(int $algo): string|false\nGets the name of the specified hash',
'mhash_keygen_s2k': '(int $algo, string $password, string $salt, int $length): string|false\nGenerates a key',
'mhash': '(int $algo, string $data, string|null $key = null): string|false\nComputes hash',
'pcntl_alarm': '(int $seconds): int\nSet an alarm clock for delivery of a signal',
'pcntl_async_signals': '(bool|null $enable = null): bool\nEnable/disable asynchronous signal handling or return the old setting',
'pcntl_errno': 'Alias of pcntl_get_last_error',
'pcntl_exec': '(string $path, array $args = [], array $env_vars = []): bool\nExecutes specified program in current process space',
'pcntl_fork': '(): int\nForks the currently running process',
'pcntl_get_last_error': '(): int\nRetrieve the error number set by the last pcntl function which failed',
'pcntl_getcpuaffinity': '(int|null $pid = null): bool|array\nGet the cpu affinity of a process',
'pcntl_getpriority': '(int|null $process_id = null, int $mode = PRIO_PROCESS): int|false\nGet the priority of any process',
'pcntl_rfork': '(int $flags, int $signal = ?): int\nManipulates process resources',
'pcntl_setcpuaffinity': '(int|null $pid = null, array $hmask = ?): bool\nSet the cpu affinity of a process',
'pcntl_setpriority': '(int $priority, int|null $process_id = null, int $mode = PRIO_PROCESS): bool\nChange the priority of any process',
'pcntl_signal_dispatch': '(): bool\nCalls signal handlers for pending signals',
'pcntl_signal_get_handler': '(int $signal): callable|int\nGet the current handler for specified signal',
'pcntl_signal': '(int $signal, callable|int $handler, bool $restart_syscalls = true): bool\nInstalls a signal handler',
'pcntl_sigprocmask': '(int $mode, array $signals, array $old_signals = null): bool\nSets and retrieves blocked signals',
'pcntl_sigtimedwait': '(array $signals, array $info = [], int $seconds = ?, int $nanoseconds = ?): int|false\nWaits for signals, with a timeout',
'pcntl_sigwaitinfo': '(array $signals, array $info = []): int|false\nWaits for signals',
'pcntl_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
'pcntl_unshare': '(int $flags): bool\nDissociates parts of the process execution context',
'pcntl_wait': '(int $status, int $flags = ?, array $resource_usage = []): int\nWaits on or returns the status of a forked child',
'pcntl_waitid': '(int $idtype = P_ALL, int|null $id = null, array $info = [], int $flags = WEXITED): bool\nWaits for a child process to change state',
'pcntl_waitpid': '(int $process_id, int $status, int $flags = ?, array $resource_usage = []): int\nWaits on or returns the status of a forked child',
'pcntl_wexitstatus': '(int $status): int|false\nReturns the return code of a terminated child',
'pcntl_wifexited': '(int $status): bool\nChecks if status code represents a normal exit',
'pcntl_wifsignaled': '(int $status): bool\nChecks whether the status code represents a termination due to a signal',
'pcntl_wifstopped': '(int $status): bool\nChecks whether the child process is currently stopped',
'pcntl_wstopsig': '(int $status): int|false\nReturns the signal which caused the child to stop',
'pcntl_wtermsig': '(int $status): int|false\nReturns the signal which caused the child to terminate',
'PDO::beginTransaction': '(): bool\nInitiates a transaction',
'PDO::commit': '(): bool\nCommits a transaction',
'PDO::connect': '(string $dsn, string|null $username = null, string|null $password = null, array|null $options = null): static\nConnect to a database and return a PDO subclass for drivers that support it',
'PDO::errorCode': '(): string|null\nFetch the SQLSTATE associated with the last operation on the database handle',
'PDO::errorInfo': '(): array\nFetch extended error information associated with the last operation on the database handle',
'PDO::exec': '(string $statement): int|false\nExecute an SQL statement and return the number of affected rows',
'PDO::getAttribute': '(int $attribute): mixed\nRetrieve a database connection attribute',
'PDO::getAvailableDrivers': '(): array\nReturn an array of available PDO drivers',
'pdo_drivers': '(): array\nReturn an array of available PDO drivers',
'PDO::inTransaction': '(): bool\nChecks if inside a transaction',
'PDO::lastInsertId': '(string|null $name = null): string|false\nReturns the ID of the last inserted row or sequence value',
'PDO::prepare': '(string $query, array $options = []): PDOStatement|false\nPrepares a statement for execution and returns a statement object',
'PDO::query': '(string $query, int|null $fetchMode = null): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_COLUMN, int $colno): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_CLASS, string $classname, array $constructorArgs): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_INTO, object $object): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
'PDO::quote': '(string $string, int $type = PDO::PARAM_STR): string|false\nQuotes a string for use in a query',
'PDO::rollBack': '(): bool\nRolls back a transaction',
'PDO::setAttribute': '(int $attribute, mixed $value): bool\nSet an attribute',
'PDOStatement::bindColumn': '(string|int $column, mixed $var, int $type = PDO::PARAM_STR, int $maxLength = ?, mixed $driverOptions = null): bool\nBind a column to a PHP variable',
'PDOStatement::bindParam': '(string|int $param, mixed $var, int $type = PDO::PARAM_STR, int $maxLength = ?, mixed $driverOptions = null): bool\nBinds a parameter to the specified variable name',
'PDOStatement::bindValue': '(string|int $param, mixed $value, int $type = PDO::PARAM_STR): bool\nBinds a value to a parameter',
'PDOStatement::closeCursor': '(): bool\nCloses the cursor, enabling the statement to be executed again',
'PDOStatement::columnCount': '(): int\nReturns the number of columns in the result set',
'PDOStatement::debugDumpParams': '(): bool|null\nDump an SQL prepared command',
'PDOStatement::errorCode': '(): string|null\nFetch the SQLSTATE associated with the last operation on the statement handle',
'PDOStatement::errorInfo': '(): array\nFetch extended error information associated with the last operation on the statement handle',
'PDOStatement::execute': '(array|null $params = null): bool\nExecutes a prepared statement',
'PDOStatement::fetch': '(int $mode = PDO::FETCH_DEFAULT, int $cursorOrientation = PDO::FETCH_ORI_NEXT, int $cursorOffset = ?): mixed\nFetches the next row from a result set',
'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_DEFAULT): array\nFetches the remaining rows from a result set',
'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_COLUMN, int $column): array\nFetches the remaining rows from a result set',
'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_CLASS, string $class, array|null $constructorArgs): array\nFetches the remaining rows from a result set',
'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_FUNC, callable $callback): array\nFetches the remaining rows from a result set',
'PDOStatement::fetchColumn': '(int $column = ?): mixed\nReturns a single column from the next row of a result set',
'PDOStatement::fetchObject': '(string|null $class = "stdClass", array $constructorArgs = []): object|false\nFetches the next row and returns it as an object',
'PDOStatement::getAttribute': '(int $name): mixed\nRetrieve a statement attribute',
'PDOStatement::getColumnMeta': '(int $column): array|false\nReturns metadata for a column in a result set',
'PDOStatement::getIterator': '(): Iterator\nGets result set iterator',
'PDOStatement::nextRowset': '(): bool\nAdvances to the next rowset in a multi-rowset statement handle',
'PDOStatement::rowCount': '(): int\nReturns the number of rows affected by the last SQL statement',
'PDOStatement::setAttribute': '(int $attribute, mixed $value): bool\nSet a statement attribute',
'PDOStatement::setFetchMode': '(int $mode): bool\nSet the default fetch mode for this statement',
'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_COLUMN, int $colno): bool\nSet the default fetch mode for this statement',
'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_CLASS, string $class, array|null $constructorArgs = null): bool\nSet the default fetch mode for this statement',
'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_INTO, object $object): bool\nSet the default fetch mode for this statement',
'Phar::addEmptyDir': '(string $directory): void\nAdd an empty directory to the phar archive',
'Phar::addFile': '(string $filename, string|null $localName = null): void\nAdd a file from the filesystem to the phar archive',
'Phar::addFromString': '(string $localName, string $contents): void\nAdd a file from a string to the phar archive',
'Phar::apiVersion': '(): string\nReturns the api version',
'Phar::buildFromDirectory': '(string $directory, string $pattern = ""): array\nConstruct a phar archive from the files within a directory',
'Phar::buildFromIterator': '(Traversable $iterator, string|null $baseDirectory = null): array\nConstruct a phar archive from an iterator',
'Phar::canCompress': '(int $compression = ?): bool\nReturns whether phar extension supports compression using either zlib or bzip2',
'Phar::canWrite': '(): bool\nReturns whether phar extension supports writing and creating phars',
'Phar::compress': '(int $compression, string|null $extension = null): Phar|null\nCompresses the entire Phar archive using Gzip or Bzip2 compression',
'Phar::compressFiles': '(int $compression): void\nCompresses all files in the current Phar archive',
'Phar::convertToData': '(int|null $format = null, int|null $compression = null, string|null $extension = null): PharData|null\nConvert a phar archive to a non-executable tar or zip file',
'Phar::convertToExecutable': '(int|null $format = null, int|null $compression = null, string|null $extension = null): Phar|null\nConvert a phar archive to another executable phar archive file format',
'Phar::copy': '(string $from, string $to): true\nCopy a file internal to the phar archive to another new file within the phar',
'Phar::count': '(int $mode = COUNT_NORMAL): int\nReturns the number of entries (files) in the Phar archive',
'Phar::createDefaultStub': '(string|null $index = null, string|null $webIndex = null): string\nCreate a phar-file format specific stub',
'Phar::decompress': '(string|null $extension = null): Phar|null\nDecompresses the entire Phar archive',
'Phar::decompressFiles': '(): true\nDecompresses all files in the current Phar archive',
'Phar::delMetadata': '(): true\nDeletes the global metadata of the phar',
'Phar::delete': '(string $localName): true\nDelete a file within a phar archive',
'Phar::extractTo': '(string $directory, array|string|null $files = null, bool $overwrite = false): bool\nExtract the contents of a phar archive to a directory',
'Phar::getAlias': '(): string|null\nGet the alias for Phar',
'Phar::getMetadata': '(array $unserializeOptions = []): mixed\nReturns phar archive meta-data',
'Phar::getModified': '(): bool\nReturn whether phar was modified',
'Phar::getPath': '(): string\nGet the real path to the Phar archive on disk',
'Phar::getSignature': '(): array|false\nReturn MD5/SHA1/SHA256/SHA512/OpenSSL signature of a Phar archive',
'Phar::getStub': '(): string\nReturn the PHP loader or bootstrap stub of a Phar archive',
'Phar::getSupportedCompression': '(): array\nReturn array of supported compression algorithms',
'Phar::getSupportedSignatures': '(): array\nReturn array of supported signature types',
'Phar::getVersion': '(): string\nReturn version info of Phar archive',
'Phar::hasMetadata': '(): bool\nReturns whether phar has global meta-data',
'Phar::interceptFileFuncs': '(): void\nInstructs phar to intercept fopen, file_get_contents, opendir, and all of the stat-related functions',
'Phar::isBuffering': '(): bool\nUsed to determine whether Phar write operations are being buffered, or are flushing directly to disk',
'Phar::isCompressed': '(): int|false\nReturns Phar::GZ or PHAR::BZ2 if the entire phar archive is compressed (.tar.gz/tar.bz and so on)',
'Phar::isFileFormat': '(int $format): bool\nReturns true if the phar archive is based on the tar/phar/zip file format depending on the parameter',
'Phar::isValidPharFilename': '(string $filename, bool $executable = true): bool\nReturns whether the given filename is a valid phar filename',
'Phar::isWritable': '(): bool\nReturns true if the phar archive can be modified',
'Phar::loadPhar': '(string $filename, string|null $alias = null): bool\nLoads any phar archive with an alias',
'Phar::mapPhar': '(string|null $alias = null, int $offset = ?): bool\nReads the currently executed file (a phar) and registers its manifest',
'Phar::mount': '(string $pharPath, string $externalPath): void\nMount an external path or file to a virtual location within the phar archive',
'Phar::mungServer': '(array $variables): void\nDefines a list of up to 4 $_SERVER variables that should be modified for execution',
'Phar::offsetExists': '(string $localName): bool\nDetermines whether a file exists in the phar',
'Phar::offsetGet': '(string $localName): SplFileInfo\nGets a PharFileInfo object for a specific file',
'Phar::offsetSet': '(string $localName, resource|string $value): void\nSet the contents of an internal file to those of an external file',
'Phar::offsetUnset': '(string $localName): void\nRemove a file from a phar',
'Phar::running': '(bool $returnPhar = true): string\nReturns the full path on disk or full phar URL to the currently executing Phar archive',
'Phar::setAlias': '(string $alias): true\nSet the alias for the Phar archive',
'Phar::setDefaultStub': '(string|null $index = null, string|null $webIndex = null): true\nUsed to set the PHP loader or bootstrap stub of a Phar archive to the default loader',
'Phar::setMetadata': '(mixed $metadata): void\nSets phar archive meta-data',
'Phar::setSignatureAlgorithm': '(int $algo, string|null $privateKey = null): void\nSet the signature algorithm for a phar and apply it',
'Phar::setStub': '(resource|string $stub, int $length = -1): bool\nUsed to set the PHP loader or bootstrap stub of a Phar archive',
'Phar::startBuffering': '(): void\nStart buffering Phar write operations, do not modify the Phar object on disk',
'Phar::stopBuffering': '(): void\nStop buffering write requests to the Phar archive, and save changes to disk',
'Phar::unlinkArchive': '(string $filename): true\nCompletely remove a phar archive from disk and from memory',
'Phar::webPhar': '(string|null $alias = null, string|null $index = null, string|null $fileNotFoundScript = null, array $mimeTypes = [], callable|null $rewrite = null): void\nRoutes a request from a web browser to an internal file within the phar archive',
'PharData::addEmptyDir': '(string $directory): void\nAdd an empty directory to the tar/zip archive',
'PharData::addFile': '(string $filename, string|null $localName = null): void\nAdd a file from the filesystem to the tar/zip archive',
'PharData::addFromString': '(string $localName, string $contents): void\nAdd a file from a string to the tar/zip archive',
'PharData::buildFromDirectory': '(string $directory, string $pattern = ""): array\nConstruct a tar/zip archive from the files within a directory',
'PharData::buildFromIterator': '(Traversable $iterator, string|null $baseDirectory = null): array\nConstruct a tar or zip archive from an iterator',
'PharData::compress': '(int $compression, string|null $extension = null): PharData|null\nCompresses the entire tar/zip archive using Gzip or Bzip2 compression',
'PharData::compressFiles': '(int $compression): void\nCompresses all files in the current tar/zip archive',
'PharData::convertToData': '(int|null $format = null, int|null $compression = null, string|null $extension = null): PharData|null\nConvert a phar archive to a non-executable tar or zip file',
'PharData::convertToExecutable': '(int|null $format = null, int|null $compression = null, string|null $extension = null): Phar|null\nConvert a non-executable tar/zip archive to an executable phar archive',
'PharData::copy': '(string $from, string $to): true\nCopy a file internal to the tar/zip archive to another new file within the same archive',
'PharData::decompress': '(string|null $extension = null): PharData|null\nDecompresses the entire Phar archive',
'PharData::decompressFiles': '(): true\nDecompresses all files in the current zip archive',
'PharData::delMetadata': '(): true\nDeletes the global metadata of a zip archive',
'PharData::delete': '(string $localName): true\nDelete a file within a tar/zip archive',
'PharData::extractTo': '(string $directory, array|string|null $files = null, bool $overwrite = false): bool\nExtract the contents of a tar/zip archive to a directory',
'PharData::isWritable': '(): bool\nReturns true if the tar/zip archive can be modified',
'PharData::offsetSet': '(string $localName, resource|string $value): void\nSet the contents of a file within the tar/zip to those of an external file or string',
'PharData::offsetUnset': '(string $localName): void\nRemove a file from a tar/zip archive',
'PharData::setAlias': '(string $alias): bool\nDummy function (Phar::setAlias is not valid for PharData)',
'PharData::setDefaultStub': '(string|null $index = null, string|null $webIndex = null): bool\nDummy function (Phar::setDefaultStub is not valid for PharData)',
'PharData::setMetadata': '(mixed $metadata): void\nSets phar archive meta-data',
'PharData::setSignatureAlgorithm': '(int $algo, string|null $privateKey = null): void\nSet the signature algorithm for a phar and apply it',
'PharData::setStub': '(string $stub, int $len = -1): bool\nDummy function (Phar::setStub is not valid for PharData)',
'PharFileInfo::chmod': '(int $perms): void\nSets file-specific permission bits',
'PharFileInfo::compress': '(int $compression): true\nCompresses the current Phar entry with either zlib or bzip2 compression',
'PharFileInfo::decompress': '(): true\nDecompresses the current Phar entry within the phar',
'PharFileInfo::delMetadata': '(): true\nDeletes the metadata of the entry',
'PharFileInfo::getCRC32': '(): int\nReturns CRC32 code or throws an exception if CRC has not been verified',
'PharFileInfo::getCompressedSize': '(): int\nReturns the actual size of the file (with compression) inside the Phar archive',
'PharFileInfo::getContent': '(): string\nGet the complete file contents of the entry',
'PharFileInfo::getMetadata': '(array $unserializeOptions = []): mixed\nReturns file-specific meta-data saved with a file',
'PharFileInfo::getPharFlags': '(): int\nReturns the Phar file entry flags',
'PharFileInfo::hasMetadata': '(): bool\nReturns the metadata of the entry',
'PharFileInfo::isCRCChecked': '(): bool\nReturns whether file entry has had its CRC verified',
'PharFileInfo::isCompressed': '(int|null $compression = null): bool\nReturns whether the entry is compressed',
'PharFileInfo::setMetadata': '(mixed $metadata): void\nSets file-specific meta-data saved with a file',
'phpdbg_break_file': '(string $file, int $line): void\nInserts a breakpoint at a line in a file',
'phpdbg_break_function': '(string $function): void\nInserts a breakpoint at entry to a function',
'phpdbg_break_method': '(string $class, string $method): void\nInserts a breakpoint at entry to a method',
'phpdbg_break_next': '(): void\nInserts a breakpoint at the next opcode',
'phpdbg_clear': '(): void\nClears all breakpoints',
'phpdbg_color': '(int $element, string $color): void\nSets the color of certain elements',
'phpdbg_end_oplog': '(array $options = []): array|null\n',
'phpdbg_exec': '(string $context): string|bool\nAttempts to set the execution context',
'phpdbg_get_executable': '(array $options = []): array\n',
'phpdbg_prompt': '(string $string): void\nSets the command prompt',
'phpdbg_start_oplog': '(): void\n',
'posix_access': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
'posix_ctermid': '(): string|false\nGet path name of controlling terminal',
'posix_eaccess': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
'posix_errno': 'Alias of posix_get_last_error',
'posix_fpathconf': '(resource|int $file_descriptor, int $name): int|false\nReturns the value of a configurable limit',
'posix_get_last_error': '(): int\nRetrieve the error number set by the last posix function that failed',
'posix_getcwd': '(): string|false\nPathname of current directory',
'posix_getegid': '(): int\nReturn the effective group ID of the current process',
'posix_geteuid': '(): int\nReturn the effective user ID of the current process',
'posix_getgid': '(): int\nReturn the real group ID of the current process',
'posix_getgrgid': '(int $group_id): array|false\nReturn info about a group by group id',
'posix_getgrnam': '(string $name): array|false\nReturn info about a group by name',
'posix_getgroups': '(): array|false\nReturn the group set of the current process',
'posix_getlogin': '(): string|false\nReturn login name',
'posix_getpgid': '(int $process_id): int|false\nGet process group id for job control',
'posix_getpgrp': '(): int\nReturn the current process group identifier',
'posix_getpid': '(): int\nReturn the current process identifier',
'posix_getppid': '(): int\nReturn the parent process identifier',
'posix_getpwnam': '(string $username): array|false\nReturn info about a user by username',
'posix_getpwuid': '(int $user_id): array|false\nReturn info about a user by user id',
'posix_getrlimit': '(int|null $resource = null): array|false\nReturn info about system resource limits',
'posix_getsid': '(int $process_id): int|false\nGet the current sid of the process',
'posix_getuid': '(): int\nReturn the real user ID of the current process',
'posix_initgroups': '(string $username, int $group_id): bool\nCalculate the group access list',
'posix_isatty': '(resource|int $file_descriptor): bool\nDetermine if a file descriptor is an interactive terminal',
'posix_kill': '(int $process_id, int $signal): bool\nSend a signal to a process',
'posix_mkfifo': '(string $filename, int $permissions): bool\nCreate a fifo special file (a named pipe)',
'posix_mknod': '(string $filename, int $flags, int $major = ?, int $minor = ?): bool\nCreate a special or ordinary file (POSIX.1)',
'posix_pathconf': '(string $path, int $name): int|false\nReturns the value of a configurable limit',
'posix_setegid': '(int $group_id): bool\nSet the effective GID of the current process',
'posix_seteuid': '(int $user_id): bool\nSet the effective UID of the current process',
'posix_setgid': '(int $group_id): bool\nSet the GID of the current process',
'posix_setpgid': '(int $process_id, int $process_group_id): bool\nSet process group id for job control',
'posix_setrlimit': '(int $resource, int $soft_limit, int $hard_limit): bool\nSet system resource limits',
'posix_setsid': '(): int\nMake the current process a session leader',
'posix_setuid': '(int $user_id): bool\nSet the UID of the current process',
'posix_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
'posix_sysconf': '(int $conf_id): int\nReturns system runtime information',
'posix_times': '(): array|false\nGet process times',
'posix_ttyname': '(resource|int $file_descriptor): string|false\nDetermine terminal device name',
'posix_uname': '(): array|false\nGet system name',
'ftok': '(string $filename, string $project_id): int\nConvert a pathname and a project identifier to a System V IPC key',
'msg_get_queue': '(int $key, int $permissions = 0666): SysvMessageQueue|false\nCreate or attach to a message queue',
'msg_queue_exists': '(int $key): bool\nCheck whether a message queue exists',
'msg_receive': '(SysvMessageQueue $queue, int $desired_message_type, int $received_message_type, int $max_message_size, mixed $message, bool $unserialize = true, int $flags = ?, int $error_code = null): bool\nReceive a message from a message queue',
'msg_remove_queue': '(SysvMessageQueue $queue): bool\nDestroy a message queue',
'msg_send': '(SysvMessageQueue $queue, int $message_type, string|int|float|bool $message, bool $serialize = true, bool $blocking = true, int $error_code = null): bool\nSend a message to a message queue',
'msg_set_queue': '(SysvMessageQueue $queue, array $data): bool\nSet information in the message queue data structure',
'msg_stat_queue': '(SysvMessageQueue $queue): array|false\nReturns information from the message queue data structure',
'sem_acquire': '(SysvSemaphore $semaphore, bool $non_blocking = false): bool\nAcquire a semaphore',
'sem_get': '(int $key, int $max_acquire = 1, int $permissions = 0666, bool $auto_release = true): SysvSemaphore|false\nGet a semaphore id',
'sem_release': '(SysvSemaphore $semaphore): bool\nRelease a semaphore',
'sem_remove': '(SysvSemaphore $semaphore): bool\nRemove a semaphore',
'shm_attach': '(int $key, int|null $size = null, int $permissions = 0666): SysvSharedMemory|false\nCreates or open a shared memory segment',
'shm_detach': '(SysvSharedMemory $shm): bool\nDisconnects from shared memory segment',
'shm_get_var': '(SysvSharedMemory $shm, int $key): mixed\nReturns a variable from shared memory',
'shm_has_var': '(SysvSharedMemory $shm, int $key): bool\nCheck whether a specific entry exists',
'shm_put_var': '(SysvSharedMemory $shm, int $key, mixed $value): bool\nInserts or updates a variable in shared memory',
'shm_remove_var': '(SysvSharedMemory $shm, int $key): bool\nRemoves a variable from shared memory',
'shm_remove': '(SysvSharedMemory $shm): bool\nRemoves shared memory from Unix systems',
'session_abort': '(): bool\nDiscard session array changes and finish session',
'session_cache_expire': '(int|null $value = null): int|false\nGet and/or set current cache expire',
'session_cache_limiter': '(string|null $value = null): string|false\nGet and/or set the current cache limiter',
'session_commit': 'Alias of session_write_close',
'session_create_id': '(string $prefix = ""): string|false\nCreate new session id',
'session_decode': '(string $data): bool\nDecodes session data from a session encoded string',
'session_destroy': '(): bool\nDestroys all data registered to a session',
'session_encode': '(): string|false\nEncodes the current session data as a session encoded string',
'session_gc': '(): int|false\nPerform session data garbage collection',
'session_get_cookie_params': '(): array\nGet the session cookie parameters',
'session_id': '(string|null $id = null): string|false\nGet and/or set the current session id',
'session_module_name': '(string|null $module = null): string|false\nGet and/or set the current session module',
'session_name': '(string|null $name = null): string|false\nGet and/or set the current session name',
'session_regenerate_id': '(bool $delete_old_session = false): bool\nUpdate the current session id with a newly generated one',
'session_register_shutdown': '(): void\nSession shutdown function',
'session_reset': '(): bool\nRe-initialize session array with original values',
'session_save_path': '(string|null $path = null): string|false\nGet and/or set the current session save path',
'session_set_cookie_params': '(int $lifetime_or_options, string|null $path = null, string|null $domain = null, bool|null $secure = null, bool|null $httponly = null): bool\nSet the session cookie parameters',
'session_set_cookie_params': '(array $lifetime_or_options): bool\nSet the session cookie parameters',
'session_set_save_handler': '(callable $open, callable $close, callable $read, callable $write, callable $destroy, callable $gc, callable $create_sid = ?, callable $validate_sid = ?, callable $update_timestamp = ?): bool\nSets user-level session storage functions',
'session_set_save_handler': '(object $sessionhandler, bool $register_shutdown = true): bool\nSets user-level session storage functions',
'session_start': '(array $options = []): bool\nStart new or resume existing session',
'session_status': '(): int\nReturns the current session status',
'session_unset': '(): bool\nFree all session variables',
'session_write_close': '(): bool\nWrite session data and end session',
'SessionHandler::close': '(): bool\nClose the session',
'SessionHandler::create_sid': '(): string\nReturn a new session ID',
'SessionHandler::destroy': '(string $id): bool\nDestroy a session',
'SessionHandler::gc': '(int $max_lifetime): int|false\nCleanup old sessions',
'SessionHandler::open': '(string $path, string $name): bool\nInitialize session',
'SessionHandler::read': '(string $id): string|false\nRead session data',
'SessionHandler::write': '(string $id, string $data): bool\nWrite session data',
'SessionHandlerInterface::close': '(): bool\nClose the session',
'SessionHandlerInterface::destroy': '(string $id): bool\nDestroy a session',
'SessionHandlerInterface::gc': '(int $max_lifetime): int|false\nCleanup old sessions',
'SessionHandlerInterface::open': '(string $path, string $name): bool\nInitialize session',
'SessionHandlerInterface::read': '(string $id): string|false\nRead session data',
'SessionHandlerInterface::write': '(string $id, string $data): bool\nWrite session data',
'SessionIdInterface::create_sid': '(): string\nCreate session ID',
'SessionUpdateTimestampHandlerInterface::updateTimestamp': '(string $id, string $data): bool\nUpdate timestamp',
'SessionUpdateTimestampHandlerInterface::validateId': '(string $id): bool\nValidate ID',
'shmop_close': '(Shmop $shmop): void\nClose shared memory block',
'shmop_delete': '(Shmop $shmop): bool\nDelete shared memory block',
'shmop_open': '(int $key, string $mode, int $permissions, int $size): Shmop|false\nCreate or open shared memory block',
'shmop_read': '(Shmop $shmop, int $offset, int $size): string\nRead data from shared memory block',
'shmop_size': '(Shmop $shmop): int\nGet size of shared memory block',
'shmop_write': '(Shmop $shmop, string $data, int $offset): int\nWrite data into shared memory block',
'socket_accept': '(Socket $socket): Socket|false\nAccepts a connection on a socket',
'socket_addrinfo_bind': '(AddressInfo $address): Socket|false\nCreate and bind to a socket from a given addrinfo',
'socket_addrinfo_connect': '(AddressInfo $address): Socket|false\nCreate and connect to a socket from a given addrinfo',
'socket_addrinfo_explain': '(AddressInfo $address): array\nGet information about addrinfo',
'socket_addrinfo_lookup': '(string $host, string|null $service = null, array $hints = []): array|false\nGet array with contents of getaddrinfo about the given hostname',
'socket_atmark': '(Socket $socket): bool\nDetermines whether socket is at out-of-band mark',
'socket_bind': '(Socket $socket, string $address, int $port = ?): bool\nBinds a name to a socket',
'socket_clear_error': '(Socket|null $socket = null): void\nClears the error on the socket or the last error code',
'socket_close': '(Socket $socket): void\nCloses a Socket instance',
'socket_cmsg_space': '(int $level, int $type, int $num = ?): int|null\nCalculate message buffer size',
'socket_connect': '(Socket $socket, string $address, int|null $port = null): bool\nInitiates a connection on a socket',
'socket_create_listen': '(int $port, int $backlog = SOMAXCONN): Socket|false\nOpens a socket on port to accept connections',
'socket_create_pair': '(int $domain, int $type, int $protocol, array $pair): bool\nCreates a pair of indistinguishable sockets and stores them in an array',
'socket_create': '(int $domain, int $type, int $protocol): Socket|false\nCreate a socket (endpoint for communication)',
'socket_export_stream': '(Socket $socket): resource|false\nExport a socket into a stream that encapsulates a socket',
'socket_get_option': '(Socket $socket, int $level, int $option): array|int|false\nGets socket options for the socket',
'socket_getopt': 'Alias of socket_get_option',
'socket_getpeername': '(Socket $socket, string $address, int $port = null): bool\nQueries the remote side of the given socket',
'socket_getsockname': '(Socket $socket, string $address, int $port = null): bool\nQueries the local side of the given socket which may either result in host/port or in a Unix filesystem path, dependent on its type',
'socket_import_stream': '(resource $stream): Socket|false\nImport a stream',
'socket_last_error': '(Socket|null $socket = null): int\nReturns the last error on the socket',
'socket_listen': '(Socket $socket, int $backlog = ?): bool\nListens for a connection on a socket',
'socket_read': '(Socket $socket, int $length, int $mode = PHP_BINARY_READ): string|false\nReads a maximum of length bytes from a socket',
'socket_recv': '(Socket $socket, string|null $data, int $length, int $flags): int|false\nReceives data from a connected socket',
'socket_recvfrom': '(Socket $socket, string $data, int $length, int $flags, string $address, int $port = null): int|false\nReceives data from a socket whether or not it is connection-oriented',
'socket_recvmsg': '(Socket $socket, array $message, int $flags = ?): int|false\nRead a message',
'socket_select': '(array|null $read, array|null $write, array|null $except, int|null $seconds, int $microseconds = ?): int|false\nRuns the select() system call on the given arrays of sockets with a specified timeout',
'socket_send': '(Socket $socket, string $data, int $length, int $flags): int|false\nSends data to a connected socket',
'socket_sendmsg': '(Socket $socket, array $message, int $flags = ?): int|false\nSend a message',
'socket_sendto': '(Socket $socket, string $data, int $length, int $flags, string $address, int|null $port = null): int|false\nSends a message to a socket, whether it is connected or not',
'socket_set_block': '(Socket $socket): bool\nSets blocking mode on a socket',
'socket_set_nonblock': '(Socket $socket): bool\nSets nonblocking mode for file descriptor fd',
'socket_set_option': '(Socket $socket, int $level, int $option, array|string|int $value): bool\nSets socket options for the socket',
'socket_setopt': 'Alias of socket_set_option',
'socket_shutdown': '(Socket $socket, int $mode = 2): bool\nShuts down a socket for receiving, sending, or both',
'socket_strerror': '(int $error_code): string\nReturn a string describing a socket error',
'socket_write': '(Socket $socket, string $data, int|null $length = null): int|false\nWrite to a socket',
'socket_wsaprotocol_info_export': '(Socket $socket, int $process_id): string|false\nExports the WSAPROTOCOL_INFO Structure',
'socket_wsaprotocol_info_import': '(string $info_id): Socket|false\nImports a Socket from another Process',
'socket_wsaprotocol_info_release': '(string $info_id): bool\nReleases an exported WSAPROTOCOL_INFO Structure',
'SQLite3::backup': '(SQLite3 $destination, string $sourceDatabase = "main", string $destinationDatabase = "main"): bool\nBackup one database to another database',
'SQLite3::busyTimeout': '(int $milliseconds): bool\nSets the busy connection handler',
'SQLite3::changes': '(): int\nReturns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement',
'SQLite3::close': '(): bool\nCloses the database connection',
'SQLite3::createAggregate': '(string $name, callable $stepCallback, callable $finalCallback, int $argCount = -1): bool\nRegisters a PHP function for use as an SQL aggregate function',
'SQLite3::createCollation': '(string $name, callable $callback): bool\nRegisters a PHP function for use as an SQL collating function',
'SQLite3::createFunction': '(string $name, callable $callback, int $argCount = -1, int $flags = ?): bool\nRegisters a PHP function for use as an SQL scalar function',
'SQLite3::enableExceptions': '(bool $enable = false): bool\nEnable throwing exceptions',
'SQLite3::escapeString': '(string $string): string\nReturns a string that has been properly escaped',
'SQLite3::exec': '(string $query): bool\nExecutes a result-less query against a given database',
'SQLite3::lastErrorCode': '(): int\nReturns the numeric result code of the most recent failed SQLite request',
'SQLite3::lastErrorMsg': '(): string\nReturns English text describing the most recent failed SQLite request',
'SQLite3::lastInsertRowID': '(): int\nReturns the row ID of the most recent INSERT into the database',
'SQLite3::loadExtension': '(string $name): bool\nAttempts to load an SQLite extension library',
'SQLite3::open': '(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryptionKey = ""): void\nOpens an SQLite database',
'SQLite3::openBlob': '(string $table, string $column, int $rowid, string $database = "main", int $flags = SQLITE3_OPEN_READONLY): resource|false\nOpens a stream resource to read a BLOB',
'SQLite3::prepare': '(string $query): SQLite3Stmt|false\nPrepares an SQL statement for execution',
'SQLite3::query': '(string $query): SQLite3Result|false\nExecutes an SQL query',
'SQLite3::querySingle': '(string $query, bool $entireRow = false): mixed\nExecutes a query and returns a single result',
'SQLite3::setAuthorizer': '(callable|null $callback): bool\nConfigures a callback to be used as an authorizer to limit what a statement can do',
'SQLite3::version': '(): array\nReturns the SQLite3 library version as a string constant and as a number',
'SQLite3Result::columnName': '(int $column): string|false\nReturns the name of the nth column',
'SQLite3Result::columnType': '(int $column): int|false\nReturns the type of the nth column',
'SQLite3Result::fetchArray': '(int $mode = SQLITE3_BOTH): array|false\nFetches a result row as an associative or numerically indexed array or both',
'SQLite3Result::finalize': '(): true\nCloses the result set',
'SQLite3Result::numColumns': '(): int\nReturns the number of columns in the result set',
'SQLite3Result::reset': '(): bool\nResets the result set back to the first row',
'SQLite3Stmt::bindParam': '(string|int $param, mixed $var, int $type = SQLITE3_TEXT): bool\nBinds a parameter to a statement variable',
'SQLite3Stmt::bindValue': '(string|int $param, mixed $value, int $type = SQLITE3_TEXT): bool\nBinds the value of a parameter to a statement variable',
'SQLite3Stmt::clear': '(): bool\nClears all current bound parameters',
'SQLite3Stmt::close': '(): true\nCloses the prepared statement',
'SQLite3Stmt::execute': '(): SQLite3Result|false\nExecutes a prepared statement and returns a result set object',
'SQLite3Stmt::getSQL': '(bool $expand = false): string|false\nGet the SQL of the statement',
'SQLite3Stmt::paramCount': '(): int\nReturns the number of parameters within the prepared statement',
'SQLite3Stmt::readOnly': '(): bool\nReturns whether a statement is definitely read only',
'SQLite3Stmt::reset': '(): bool\nResets the prepared statement',
'token_get_all': '(string $code, int $flags = ?): array\nSplit given source into PHP tokens',
'token_name': '(int $id): string\nGet the symbolic name of a given PHP token',
'PhpToken::getTokenName': '(): string|null\nReturns the name of the token.',
'PhpToken::is': '(int|string|array $kind): bool\nTells whether the token is of given kind.',
'PhpToken::isIgnorable': '(): bool\nTells whether the token would be ignored by the PHP parser.',
'PhpToken::__toString': '(): string\nReturns the textual content of the token.',
'PhpToken::tokenize': '(string $code, int $flags = ?): array\nSplits given source into PHP tokens, represented by PhpToken objects.',
'deflate_add': '(DeflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally deflate data',
'deflate_init': '(int $encoding, array $options = []): DeflateContext|false\nInitialize an incremental deflate context',
'gzclose': '(resource $stream): bool\nClose an open gz-file pointer',
'gzcompress': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_DEFLATE): string|false\nCompress a string',
'gzdecode': '(string $data, int $max_length = ?): string|false\nDecodes a gzip compressed string',
'gzdeflate': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_RAW): string|false\nDeflate a string',
'gzencode': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_GZIP): string|false\nCreate a gzip compressed string',
'gzeof': '(resource $stream): bool\nTest for EOF on a gz-file pointer',
'gzfile': '(string $filename, int $use_include_path = ?): array|false\nRead entire gz-file into an array',
'gzgetc': '(resource $stream): string|false\nGet character from gz-file pointer',
'gzgets': '(resource $stream, int|null $length = null): string|false\nGet line from file pointer',
'gzgetss': '(resource $zp, int $length, string $allowable_tags = ?): string\nGet line from gz-file pointer and strip HTML tags',
'gzinflate': '(string $data, int $max_length = ?): string|false\nInflate a deflated string',
'gzopen': '(string $filename, string $mode, int $use_include_path = ?): resource|false\nOpen gz-file',
'gzpassthru': '(resource $stream): int\nOutput all remaining data on a gz-file pointer',
'gzputs': 'Alias of gzwrite',
'gzread': '(resource $stream, int $length): string|false\nBinary-safe gz-file read',
'gzrewind': '(resource $stream): bool\nRewind the position of a gz-file pointer',
'gzseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeek on a gz-file pointer',
'gztell': '(resource $stream): int|false\nTell gz-file pointer read/write position',
'gzuncompress': '(string $data, int $max_length = ?): string|false\nUncompress a compressed string',
'gzwrite': '(resource $stream, string $data, int|null $length = null): int|false\nBinary-safe gz-file write',
'inflate_get_read_len': '(InflateContext $context): int\nGet number of bytes read so far',
'inflate_get_status': '(InflateContext $context): int\nGet decompression status',
'inflate_add': '(InflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally inflate encoded data',
'inflate_init': '(int $encoding, array $options = []): InflateContext|false\nInitialize an incremental inflate context',
'ob_gzhandler': '(string $data, int $flags): string|false\nob_start callback function to gzip output buffer',
'readgzfile': '(string $filename, int $use_include_path = ?): int|false\nOutput a gz-file',
'zlib_decode': '(string $data, int $max_length = ?): string|false\nUncompress any raw/gzip/zlib encoded data',
'zlib_encode': '(string $data, int $encoding, int $level = -1): string|false\nCompress data with the specified encoding',
'zlib_get_coding_type': '(): string|false\nReturns the coding type used for output compression',
'bzclose': '(resource $bz): bool\nClose a bzip2 file',
'bzcompress': '(string $data, int $block_size = 4, int $work_factor = ?): string|int\nCompress a string into bzip2 encoded data',
'bzdecompress': '(string $data, bool $use_less_memory = false): string|int|false\nDecompresses bzip2 encoded data',
'bzerrno': '(resource $bz): int\nReturns a bzip2 error number',
'bzerror': '(resource $bz): array\nReturns the bzip2 error number and error string in an array',
'bzerrstr': '(resource $bz): string\nReturns a bzip2 error string',
'bzflush': '(resource $bz): bool\nDo nothing',
'bzopen': '(string|resource $file, string $mode): resource|false\nOpens a bzip2 compressed file',
'bzread': '(resource $bz, int $length = 1024): string|false\nBinary safe bzip2 file read',
'bzwrite': '(resource $bz, string $data, int|null $length = null): int|false\nBinary safe bzip2 file write',
'curl_file_create': '(string $filename, string|null $mime_type = null, string|null $posted_filename = null): CURLFile\nCreate a CURLFile object',
'CURLFile::getFilename': '(): string\nGet file name',
'CURLFile::getMimeType': '(): string\nGet MIME type',
'CURLFile::getPostFilename': '(): string\nGet file name for POST',
'CURLFile::setMimeType': '(string $mime_type): void\nSet MIME type',
'CURLFile::setPostFilename': '(string $posted_filename): void\nSet file name for POST',
'curl_close': '(CurlHandle $handle): void\nClose a cURL session',
'curl_copy_handle': '(CurlHandle $handle): CurlHandle|false\nCopy a cURL handle along with all of its preferences',
'curl_errno': '(CurlHandle $handle): int\nReturn the last error number',
'curl_error': '(CurlHandle $handle): string\nReturn a string containing the last error for the current session',
'curl_escape': '(CurlHandle $handle, string $string): string|false\nURL encodes the given string',
'curl_exec': '(CurlHandle $handle): string|bool\nPerform a cURL session',
'curl_getinfo': '(CurlHandle $handle, int|null $option = null): mixed\nGet information regarding a specific transfer',
'curl_init': '(string|null $url = null): CurlHandle|false\nInitialize a cURL session',
'curl_multi_add_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nAdd a normal cURL handle to a cURL multi handle',
'curl_multi_close': '(CurlMultiHandle $multi_handle): void\nRemove all cURL handles from a multi handle',
'curl_multi_errno': '(CurlMultiHandle $multi_handle): int\nReturn the last multi curl error number',
'curl_multi_exec': '(CurlMultiHandle $multi_handle, int $still_running): int\nRun the sub-connections of the current cURL handle',
'curl_multi_getcontent': '(CurlHandle $handle): string|null\nReturn the content of a cURL handle if CURLOPT_RETURNTRANSFER is set',
'curl_multi_info_read': '(CurlMultiHandle $multi_handle, int $queued_messages = null): array|false\nGet information about the current transfers',
'curl_multi_init': '(): CurlMultiHandle\nReturns a new cURL multi handle',
'curl_multi_remove_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nRemove a handle from a set of cURL handles',
'curl_multi_select': '(CurlMultiHandle $multi_handle, float $timeout = 1.0): int\nWait until reading or writing is possible for any cURL multi handle connection',
'curl_multi_setopt': '(CurlMultiHandle $multi_handle, int $option, mixed $value): bool\nSet a cURL multi option',
'curl_multi_strerror': '(int $error_code): string|null\nReturn string describing error code',
'curl_pause': '(CurlHandle $handle, int $flags): int\nPause and unpause a connection',
'curl_reset': '(CurlHandle $handle): void\nReset all options of a libcurl session handle',
'curl_setopt_array': '(CurlHandle $handle, array $options): bool\nSet multiple options for a cURL transfer',
'curl_setopt': '(CurlHandle $handle, int $option, mixed $value): bool\nSet an option for a cURL transfer',
'curl_share_close': '(CurlShareHandle $share_handle): void\nClose a cURL share handle',
'curl_share_errno': '(CurlShareHandle $share_handle): int\nReturn the last share curl error number',
'curl_share_init_persistent': '(array $share_options): CurlSharePersistentHandle\nInitialize a persistent cURL share handle',
'curl_share_init': '(): CurlShareHandle\nInitialize a cURL share handle',
'curl_share_setopt': '(CurlShareHandle $share_handle, int $option, mixed $value): bool\nSet an option for a cURL share handle',
'curl_share_strerror': '(int $error_code): string|null\nReturn string describing the given error code',
'curl_strerror': '(int $error_code): string|null\nReturn string describing the given error code',
'curl_unescape': '(CurlHandle $handle, string $string): string|false\nDecodes the given URL encoded string',
'curl_upkeep': '(CurlHandle $handle): bool\nPerforms any connection upkeep checks',
'curl_version': '(): array|false\nGets cURL version information',
'Dom\\Attr::isId': '(): bool\n',
'Dom\\Attr::rename': '(string|null $namespaceURI, string $qualifiedName): void\nChanges the qualified name or namespace of an attribute',
'Dom\\CharacterData::after': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\CharacterData::appendData': '(string $data): void\n',
'Dom\\CharacterData::before': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\CharacterData::deleteData': '(int $offset, int $count): void\n',
'Dom\\CharacterData::insertData': '(int $offset, string $data): void\n',
'Dom\\CharacterData::remove': '(): void\n',
'Dom\\CharacterData::replaceData': '(int $offset, int $count, string $data): void\n',
'Dom\\CharacterData::replaceWith': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\CharacterData::substringData': '(int $offset, int $count): string\n',
'Dom\\ChildNode::after': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\ChildNode::before': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\ChildNode::remove': '(): void\n',
'Dom\\ChildNode::replaceWith': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\HTMLDocument::createEmpty': '(string $encoding = "UTF-8"): Dom\\HTMLDocument\nCreates an empty HTML document',
'Dom\\HTMLDocument::createFromFile': '(string $path, int $options = ?, string|null $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a file',
'Dom\\HTMLDocument::createFromString': '(string $source, int $options = ?, string|null $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a string',
'Dom\\HTMLDocument::saveHtml': '(Dom\\Node|null $node = null): string\nSerializes the document as an HTML string',
'Dom\\HTMLDocument::saveHtmlFile': '(string $filename): int|false\nSerializes the document as an HTML file',
'Dom\\HTMLDocument::saveXml': '(Dom\\Node|null $node = null, int $options = ?): string|false\nSerializes the document as an XML string',
'Dom\\HTMLDocument::saveXmlFile': '(string $filename, int $options = ?): int|false\nSerializes the document as an XML file',
'Dom\\ParentNode::append': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\ParentNode::prepend': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\ParentNode::querySelector': '(string $selectors): Dom\\Element|null\nReturns the first element that matches the CSS selectors',
'Dom\\ParentNode::querySelectorAll': '(string $selectors): Dom\\NodeList\nReturns a collection of elements that match the CSS selectors',
'Dom\\ParentNode::replaceChildren': '(Dom\\Node|string ...$nodes): void\n',
'Dom\\Text::splitText': '(int $offset): Dom\\Text\n',
'Dom\\TokenList::add': '(string ...$tokens): void\nAdds the given tokens to the list',
'Dom\\TokenList::contains': '(string $token): bool\nReturns whether the list contains a given token',
'Dom\\TokenList::count': '(): int\nReturns the number of tokens in the list',
'Dom\\TokenList::getIterator': '(): Iterator\nReturns an iterator over the token list',
'Dom\\TokenList::item': '(int $index): string|null\nReturns a token from the list',
'Dom\\TokenList::remove': '(string ...$tokens): void\nRemoves the given tokens from the list',
'Dom\\TokenList::replace': '(string $token, string $newToken): bool\nReplaces a token in the list with another one',
'Dom\\TokenList::supports': '(string $token): bool\nReturns whether the given token is supported',
'Dom\\TokenList::toggle': '(string $token, bool|null $force = null): bool\nToggles the presence of a token in the list',
'DOMAttr::isId': '(): bool\nChecks if attribute is a defined ID',
'DOMCharacterData::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the character data',
'DOMCharacterData::appendData': '(string $data): true\nAppend the string to the end of the character data of the node',
'DOMCharacterData::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the character data',
'DOMCharacterData::deleteData': '(int $offset, int $count): bool\nRemove a range of characters from the character data',
'DOMCharacterData::insertData': '(int $offset, string $data): bool\nInsert a string at the specified UTF-8 codepoint offset',
'DOMCharacterData::remove': '(): void\nRemoves the character data node',
'DOMCharacterData::replaceData': '(int $offset, int $count, string $data): bool\nReplace a substring within the character data',
'DOMCharacterData::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the character data with new nodes',
'DOMCharacterData::substringData': '(int $offset, int $count): string|false\nExtracts a range of data from the character data',
'DOMChildNode::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the node',
'DOMChildNode::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the node',
'DOMChildNode::remove': '(): void\nRemoves the node',
'DOMChildNode::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the node with new nodes',
'DOMDocument::adoptNode': '(DOMNode $node): DOMNode|false\nTransfer a node from another document',
'DOMDocument::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
'DOMDocument::createAttribute': '(string $localName): DOMAttr|false\nCreate new attribute',
'DOMDocument::createAttributeNS': '(string|null $namespace, string $qualifiedName): DOMAttr|false\nCreate new attribute node with an associated namespace',
'DOMDocument::createCDATASection': '(string $data): DOMCdataSection|false\nCreate new cdata node',
'DOMDocument::createComment': '(string $data): DOMComment\nCreate new comment node',
'DOMDocument::createDocumentFragment': '(): DOMDocumentFragment\nCreate new document fragment',
'DOMDocument::createElement': '(string $localName, string $value = ""): DOMElement|false\nCreate new element node',
'DOMDocument::createElementNS': '(string|null $namespace, string $qualifiedName, string $value = ""): DOMElement|false\nCreate new element node with an associated namespace',
'DOMDocument::createEntityReference': '(string $name): DOMEntityReference|false\nCreate new entity reference node',
'DOMDocument::createProcessingInstruction': '(string $target, string $data = ""): DOMProcessingInstruction|false\nCreates new PI node',
'DOMDocument::createTextNode': '(string $data): DOMText\nCreate new text node',
'DOMDocument::getElementById': '(string $elementId): DOMElement|null\nSearches for an element with a certain id',
'DOMDocument::getElementsByTagName': '(string $qualifiedName): DOMNodeList\nSearches for all elements with given local tag name',
'DOMDocument::getElementsByTagNameNS': '(string|null $namespace, string $localName): DOMNodeList\nSearches for all elements with given tag name in specified namespace',
'DOMDocument::importNode': '(DOMNode $node, bool $deep = false): DOMNode|false\nImport node into current document',
'DOMDocument::load': '(string $filename, int $options = ?): bool\nLoad XML from a file',
'DOMDocument::loadHTML': '(string $source, int $options = ?): bool\nLoad HTML from a string',
'DOMDocument::loadHTMLFile': '(string $filename, int $options = ?): bool\nLoad HTML from a file',
'DOMDocument::loadXML': '(string $source, int $options = ?): bool\nLoad XML from a string',
'DOMDocument::normalizeDocument': '(): void\nNormalizes the document',
'DOMDocument::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
'DOMDocument::registerNodeClass': '(string $baseClass, string|null $extendedClass): true\nRegister extended class used to create base node type',
'DOMDocument::relaxNGValidate': '(string $filename): bool\nPerforms relaxNG validation on the document',
'DOMDocument::relaxNGValidateSource': '(string $source): bool\nPerforms relaxNG validation on the document',
'DOMDocument::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in document',
'DOMDocument::save': '(string $filename, int $options = ?): int|false\nDumps the internal XML tree back into a file',
'DOMDocument::saveHTML': '(DOMNode|null $node = null): string|false\nDumps the internal document into a string using HTML formatting',
'DOMDocument::saveHTMLFile': '(string $filename): int|false\nDumps the internal document into a file using HTML formatting',
'DOMDocument::saveXML': '(DOMNode|null $node = null, int $options = ?): string|false\nDumps the internal XML tree back into a string',
'DOMDocument::schemaValidate': '(string $filename, int $flags = ?): bool\nValidates a document based on a schema. Only XML Schema 1.0 is supported.',
'DOMDocument::schemaValidateSource': '(string $source, int $flags = ?): bool\nValidates a document based on a schema',
'DOMDocument::validate': '(): bool\nValidates the document based on its DTD',
'DOMDocument::xinclude': '(int $options = ?): int|false\nSubstitutes XIncludes in a DOMDocument Object',
'DOMDocumentFragment::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
'DOMDocumentFragment::appendXML': '(string $data): bool\nAppend raw XML data',
'DOMDocumentFragment::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
'DOMDocumentFragment::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in fragment',
'DOMElement::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the element',
'DOMElement::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
'DOMElement::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the element',
'DOMElement::getAttribute': '(string $qualifiedName): string\nReturns value of attribute',
'DOMElement::getAttributeNames': '(): array\nGet attribute names',
'DOMElement::getAttributeNode': '(string $qualifiedName): DOMAttr|DOMNameSpaceNode|false\nReturns attribute node',
'DOMElement::getAttributeNodeNS': '(string|null $namespace, string $localName): DOMAttr|DOMNameSpaceNode|null\nReturns attribute node',
'DOMElement::getAttributeNS': '(string|null $namespace, string $localName): string\nReturns value of attribute',
'DOMElement::getElementsByTagName': '(string $qualifiedName): DOMNodeList\nGets elements by tagname',
'DOMElement::getElementsByTagNameNS': '(string|null $namespace, string $localName): DOMNodeList\nGet elements by namespaceURI and localName',
'DOMElement::hasAttribute': '(string $qualifiedName): bool\nChecks to see if attribute exists',
'DOMElement::hasAttributeNS': '(string|null $namespace, string $localName): bool\nChecks to see if attribute exists',
'DOMElement::insertAdjacentElement': '(string $where, DOMElement $element): DOMElement|null\nInsert adjacent element',
'DOMElement::insertAdjacentText': '(string $where, string $data): void\nInsert adjacent text',
'DOMElement::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
'DOMElement::remove': '(): void\nRemoves the element',
'DOMElement::removeAttribute': '(string $qualifiedName): bool\nRemoves attribute',
'DOMElement::removeAttributeNode': '(DOMAttr $attr): DOMAttr|false\nRemoves attribute',
'DOMElement::removeAttributeNS': '(string|null $namespace, string $localName): void\nRemoves attribute',
'DOMElement::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in element',
'DOMElement::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the element with new nodes',
'DOMElement::setAttribute': '(string $qualifiedName, string $value): DOMAttr|bool\nAdds new or modifies existing attribute',
'DOMElement::setAttributeNode': '(DOMAttr $attr): DOMAttr|null|false\nAdds new attribute node to element',
'DOMElement::setAttributeNodeNS': '(DOMAttr $attr): DOMAttr|null|false\nAdds new attribute node to element',
'DOMElement::setAttributeNS': '(string|null $namespace, string $qualifiedName, string $value): void\nAdds new attribute',
'DOMElement::setIdAttribute': '(string $qualifiedName, bool $isId): void\nDeclares the attribute specified by name to be of type ID',
'DOMElement::setIdAttributeNode': '(DOMAttr $attr, bool $isId): void\nDeclares the attribute specified by node to be of type ID',
'DOMElement::setIdAttributeNS': '(string $namespace, string $qualifiedName, bool $isId): void\nDeclares the attribute specified by local name and namespace URI to be of type ID',
'DOMElement::toggleAttribute': '(string $qualifiedName, bool|null $force = null): bool\nToggle attribute',
'DOMImplementation::createDocument': '(string|null $namespace = null, string $qualifiedName = "", DOMDocumentType|null $doctype = null): DOMDocument\nCreates a DOMDocument object of the specified type with its document element',
'DOMImplementation::createDocumentType': '(string $qualifiedName, string $publicId = "", string $systemId = ""): DOMDocumentType|false\nCreates an empty DOMDocumentType object',
'DOMImplementation::hasFeature': '(string $feature, string $version): bool\nTest if the DOM implementation implements a specific feature',
'DOMNamedNodeMap::count': '(): int\nGet number of nodes in the map',
'DOMNamedNodeMap::getIterator': '(): Iterator\nRetrieve an external iterator',
'DOMNamedNodeMap::getNamedItem': '(string $qualifiedName): DOMNode|null\nRetrieves a node specified by name',
'DOMNamedNodeMap::getNamedItemNS': '(string|null $namespace, string $localName): DOMNode|null\nRetrieves a node specified by local name and namespace URI',
'DOMNamedNodeMap::item': '(int $index): DOMNode|null\nRetrieves a node specified by index',
'DOMNameSpaceNode::__sleep': '(): array\nForbids serialization unless serialization methods are implemented in a subclass',
'DOMNameSpaceNode::__wakeup': '(): void\nForbids unserialization unless unserialization methods are implemented in a subclass',
'DOMNode::appendChild': '(DOMNode $node): DOMNode|false\nAdds new child at the end of the children',
'DOMNode::C14N': '(bool $exclusive = false, bool $withComments = false, array|null $xpath = null, array|null $nsPrefixes = null): string|false\nCanonicalize nodes to a string',
'DOMNode::C14NFile': '(string $uri, bool $exclusive = false, bool $withComments = false, array|null $xpath = null, array|null $nsPrefixes = null): int|false\nCanonicalize nodes to a file',
'DOMNode::cloneNode': '(bool $deep = false): DOMNode|false\nClones a node',
'DOMNode::compareDocumentPosition': '(DOMNode $other): int\nCompares the position of two nodes',
'DOMNode::contains': '(DOMNode|DOMNameSpaceNode|null $other): bool\nChecks if node contains other node',
'DOMNode::getLineNo': '(): int\nGet line number for a node',
'DOMNode::getNodePath': '(): string|null\nGet an XPath for a node',
'DOMNode::getRootNode': '(array|null $options = null): DOMNode\nGet root node',
'DOMNode::hasAttributes': '(): bool\nChecks if node has attributes',
'DOMNode::hasChildNodes': '(): bool\nChecks if node has children',
'DOMNode::insertBefore': '(DOMNode $node, DOMNode|null $child = null): DOMNode|false\nAdds a new child before a reference node',
'DOMNode::isDefaultNamespace': '(string $namespace): bool\nChecks if the specified namespaceURI is the default namespace or not',
'DOMNode::isEqualNode': '(DOMNode|null $otherNode): bool\nChecks that both nodes are equal',
'DOMNode::isSameNode': '(DOMNode $otherNode): bool\nIndicates if two nodes are the same node',
'DOMNode::isSupported': '(string $feature, string $version): bool\nChecks if feature is supported for specified version',
'DOMNode::lookupNamespaceURI': '(string|null $prefix): string|null\nGets the namespace URI of the node based on the prefix',
'DOMNode::lookupPrefix': '(string $namespace): string|null\nGets the namespace prefix of the node based on the namespace URI',
'DOMNode::normalize': '(): void\nNormalizes the node',
'DOMNode::removeChild': '(DOMNode $child): DOMNode|false\nRemoves child from list of children',
'DOMNode::replaceChild': '(DOMNode $node, DOMNode $child): DOMNode|false\nReplaces a child',
'DOMNode::__sleep': '(): array\nForbids serialization unless serialization methods are implemented in a subclass',
'DOMNode::__wakeup': '(): void\nForbids unserialization unless unserialization methods are implemented in a subclass',
'DOMNodeList::count': '(): int\nGet number of nodes in the list',
'DOMNodeList::getIterator': '(): Iterator\nRetrieve an external iterator',
'DOMNodeList::item': '(int $index): DOMElement|DOMNode|DOMNameSpaceNode|null\nRetrieves a node specified by index',
'DOMParentNode::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
'DOMParentNode::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
'DOMParentNode::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in node',
'DOMText::isElementContentWhitespace': '(): bool\nReturns whether this text node contains whitespace in element content',
'DOMText::isWhitespaceInElementContent': '(): bool\nIndicates whether this text node contains whitespace',
'DOMText::splitText': '(int $offset): DOMText|false\nBreaks this node into two nodes at the specified offset',
'DOMXPath::evaluate': '(string $expression, DOMNode|null $contextNode = null, bool $registerNodeNS = true): mixed\nEvaluates the given XPath expression and returns a typed result if possible',
'DOMXPath::query': '(string $expression, DOMNode|null $contextNode = null, bool $registerNodeNS = true): mixed\nEvaluates the given XPath expression',
'DOMXPath::quote': '(string $str): string\nQuotes a string for use in an XPath expression',
'DOMXPath::registerNamespace': '(string $prefix, string $namespace): bool\nRegisters the namespace with the DOMXPath object',
'DOMXPath::registerPhpFunctionNS': '(string $namespaceURI, string $name, callable $callable): void\nRegister a PHP functions as namespaced XPath function',
'DOMXPath::registerPhpFunctions': '(string|array|null $restrict = null): void\nRegister PHP functions as XPath functions',
'dom_import_simplexml': '(object $node): DOMAttr|DOMElement\nGets a DOMAttr or DOMElement object from a SimpleXMLElement object',
'Dom\\import_simplexml': '(object $node): Dom\\Attr|Dom\\Element\nGets a Dom\\Attr or Dom\\Element object from a SimpleXMLElement object',
'enchant_broker_describe': '(EnchantBroker $broker): array\nEnumerates the Enchant providers',
'enchant_broker_dict_exists': '(EnchantBroker $broker, string $tag): bool\nWhether a dictionary exists or not. Using non-empty tag',
'enchant_broker_free_dict': '(EnchantDictionary $dictionary): bool\nFree a dictionary resource',
'enchant_broker_free': '(EnchantBroker $broker): bool\nFree the broker resource and its dictionaries',
'enchant_broker_get_dict_path': '(EnchantBroker $broker, int $type): string|false\nGet the directory path for a given backend',
'enchant_broker_get_error': '(EnchantBroker $broker): string|false\nReturns the last error of the broker',
'enchant_broker_init': '(): EnchantBroker|false\nCreate a new broker object capable of requesting',
'enchant_broker_list_dicts': '(EnchantBroker $broker): array\nReturns a list of available dictionaries',
'enchant_broker_request_dict': '(EnchantBroker $broker, string $tag): EnchantDictionary|false\nCreate a new dictionary using a tag',
'enchant_broker_request_pwl_dict': '(EnchantBroker $broker, string $filename): EnchantDictionary|false\nCreates a dictionary using a PWL file',
'enchant_broker_set_dict_path': '(EnchantBroker $broker, int $type, string $path): bool\nSet the directory path for a given backend',
'enchant_broker_set_ordering': '(EnchantBroker $broker, string $tag, string $ordering): bool\nDeclares a preference of dictionaries to use for the language',
'enchant_dict_add_to_personal': 'Alias of enchant_dict_add',
'enchant_dict_add_to_session': '(EnchantDictionary $dictionary, string $word): void\nAdd \'word\' to this spell-checking session',
'enchant_dict_add': '(EnchantDictionary $dictionary, string $word): void\nAdd a word to personal word list',
'enchant_dict_check': '(EnchantDictionary $dictionary, string $word): bool\nCheck whether a word is correctly spelled or not',
'enchant_dict_describe': '(EnchantDictionary $dictionary): array\nDescribes an individual dictionary',
'enchant_dict_get_error': '(EnchantDictionary $dictionary): string|false\nReturns the last error of the current spelling-session',
'enchant_dict_is_added': '(EnchantDictionary $dictionary, string $word): bool\nWhether or not \'word\' exists in this spelling-session',
'enchant_dict_is_in_session': 'Alias of enchant_dict_is_added',
'enchant_dict_quick_check': '(EnchantDictionary $dictionary, string $word, array $suggestions = null): bool\nCheck the word is correctly spelled and provide suggestions',
'enchant_dict_store_replacement': '(EnchantDictionary $dictionary, string $misspelled, string $correct): void\nAdd a correction for a word',
'enchant_dict_suggest': '(EnchantDictionary $dictionary, string $word): array\nWill return a list of values if any of those pre-conditions are not met',
'_': 'Alias of gettext',
'bind_textdomain_codeset': '(string $domain, string|null $codeset = null): string|false\nSpecify or get the character encoding in which the messages from the DOMAIN message catalog will be returned',
'bindtextdomain': '(string $domain, string|null $directory = null): string|false\nSets or gets the path for a domain',
'dcgettext': '(string $domain, string $message, int $category): string\nOverrides the domain for a single lookup',
'dcngettext': '(string $domain, string $singular, string $plural, int $count, int $category): string\nPlural version of dcgettext',
'dgettext': '(string $domain, string $message): string\nOverride the current domain',
'dngettext': '(string $domain, string $singular, string $plural, int $count): string\nPlural version of dgettext',
'gettext': '(string $message): string\nLookup a message in the current domain',
'ngettext': '(string $singular, string $plural, int $count): string\nPlural version of gettext',
'textdomain': '(string|null $domain = null): string\nSets the default domain',
'gmp_abs': '(GMP|int|string $num): GMP\nAbsolute value',
'gmp_add': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nAdd numbers',
'gmp_and': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise AND',
'gmp_binomial': '(GMP|int|string $n, int $k): GMP\nCalculates binomial coefficient',
'gmp_clrbit': '(GMP $num, int $index): void\nClear bit',
'gmp_cmp': '(GMP|int|string $num1, GMP|int|string $num2): int\nCompare numbers',
'gmp_com': '(GMP|int|string $num): GMP\nCalculates one\'s complement',
'gmp_div_q': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nDivide numbers',
'gmp_div_qr': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): array\nDivide numbers and get quotient and remainder',
'gmp_div_r': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nRemainder of the division of numbers',
'gmp_div': 'Alias of gmp_div_q',
'gmp_divexact': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nExact division of numbers',
'gmp_export': '(GMP|int|string $num, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): string\nExport to a binary string',
'gmp_fact': '(GMP|int|string $num): GMP\nFactorial',
'gmp_gcd': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate GCD',
'gmp_gcdext': '(GMP|int|string $num1, GMP|int|string $num2): array\nCalculate GCD and multipliers',
'gmp_hamdist': '(GMP|int|string $num1, GMP|int|string $num2): int\nHamming distance',
'gmp_import': '(string $data, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): GMP\nImport from a binary string',
'gmp_init': '(int|string $num, int $base = ?): GMP\nCreate GMP number',
'gmp_intval': '(GMP|int|string $num): int\nConvert GMP number to integer',
'gmp_invert': '(GMP|int|string $num1, GMP|int|string $num2): GMP|false\nInverse by modulo',
'gmp_jacobi': '(GMP|int|string $num1, GMP|int|string $num2): int\nJacobi symbol',
'gmp_kronecker': '(GMP|int|string $num1, GMP|int|string $num2): int\nKronecker symbol',
'gmp_lcm': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate LCM',
'gmp_legendre': '(GMP|int|string $num1, GMP|int|string $num2): int\nLegendre symbol',
'gmp_mod': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nModulo operation',
'gmp_mul': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nMultiply numbers',
'gmp_neg': '(GMP|int|string $num): GMP\nNegate number',
'gmp_nextprime': '(GMP|int|string $num): GMP\nFind next prime number',
'gmp_or': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise OR',
'gmp_perfect_power': '(GMP|int|string $num): bool\nPerfect power check',
'gmp_perfect_square': '(GMP|int|string $num): bool\nPerfect square check',
'gmp_popcount': '(GMP|int|string $num): int\nPopulation count',
'gmp_pow': '(GMP|int|string $num, int $exponent): GMP\nRaise number into power',
'gmp_powm': '(GMP|int|string $num, GMP|int|string $exponent, GMP|int|string $modulus): GMP\nRaise number into power with modulo',
'gmp_prob_prime': '(GMP|int|string $num, int $repetitions = 10): int\nCheck if number is "probably prime"',
'gmp_random_bits': '(int $bits): GMP\nRandom number',
'gmp_random_range': '(GMP|int|string $min, GMP|int|string $max): GMP\nGet a uniformly selected integer',
'gmp_random_seed': '(GMP|int|string $seed): void\nSets the RNG seed',
'gmp_random': '(int $limiter = 20): GMP\nRandom number',
'gmp_root': '(GMP|int|string $num, int $nth): GMP\nTake the integer part of nth root',
'gmp_rootrem': '(GMP|int|string $num, int $nth): array\nTake the integer part and remainder of nth root',
'gmp_scan0': '(GMP|int|string $num1, int $start): int\nScan for 0',
'gmp_scan1': '(GMP|int|string $num1, int $start): int\nScan for 1',
'gmp_setbit': '(GMP $num, int $index, bool $value = true): void\nSet bit',
'gmp_sign': '(GMP|int|string $num): int\nSign of number',
'gmp_sqrt': '(GMP|int|string $num): GMP\nCalculate square root',
'gmp_sqrtrem': '(GMP|int|string $num): array\nSquare root with remainder',
'gmp_strval': '(GMP|int|string $num, int $base = 10): string\nConvert GMP number to string',
'gmp_sub': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nSubtract numbers',
'gmp_testbit': '(GMP|int|string $num, int $index): bool\nTests if a bit is set',
'gmp_xor': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise XOR',
'GMP::__serialize': '(): array\nSerializes the GMP object',
'GMP::__unserialize': '(array $data): void\nDeserializes the $data parameter into a GMP object',
'ldap_8859_to_t61': '(string $value): string|false\nTranslate 8859 characters to t61 characters',
'ldap_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nAdd entries to LDAP directory',
'ldap_add': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nAdd entries to LDAP directory',
'ldap_bind_ext': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null, array|null $controls = null): LDAP\\Result|false\nBind to LDAP directory',
'ldap_bind': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null): bool\nBind to LDAP directory',
'ldap_close': 'Alias of ldap_unbind',
'ldap_compare': '(LDAP\\Connection $ldap, string $dn, string $attribute, string $value, array|null $controls = null): bool|int\nCompare value of attribute found in entry specified with DN',
'ldap_connect_wallet': '(string|null $uri = null, string $wallet, string $password, int $auth_mode = GSLC_SSL_NO_AUTH): LDAP\\Connection|false\nConnect to an LDAP server',
'ldap_connect': '(string|null $uri = null): LDAP\\Connection|false\nConnect to an LDAP server',
'ldap_connect': '(string|null $host = null, int $port = 389): LDAP\\Connection|false\nConnect to an LDAP server',
'ldap_control_paged_result_response': '(resource $link, resource $result, string $cookie = ?, int $estimated = ?): bool\nRetrieve the LDAP pagination cookie',
'ldap_control_paged_result': '(resource $link, int $pagesize, bool $iscritical = false, string $cookie = ""): bool\nSend LDAP pagination control',
'ldap_count_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCount the number of entries in a search',
'ldap_count_references': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCounts the number of references in a search result',
'ldap_delete_ext': '(LDAP\\Connection $ldap, string $dn, array|null $controls = null): LDAP\\Result|false\nDelete an entry from a directory',
'ldap_delete': '(LDAP\\Connection $ldap, string $dn, array|null $controls = null): bool\nDelete an entry from a directory',
'ldap_dn2ufn': '(string $dn): string|false\nConvert DN to User Friendly Naming format',
'ldap_err2str': '(int $errno): string\nConvert LDAP error number into string error message',
'ldap_errno': '(LDAP\\Connection $ldap): int\nReturn the LDAP error number of the last LDAP command',
'ldap_error': '(LDAP\\Connection $ldap): string\nReturn the LDAP error message of the last LDAP command',
'ldap_escape': '(string $value, string $ignore = "", int $flags = ?): string\nEscape a string for use in an LDAP filter or DN',
'ldap_exop_passwd': '(LDAP\\Connection $ldap, string $user = "", string $old_password = "", string $new_password = "", array $controls = null): string|bool\nPASSWD extended operation helper',
'ldap_exop_refresh': '(LDAP\\Connection $ldap, string $dn, int $ttl): int|false\nRefresh extended operation helper',
'ldap_exop_sync': '(LDAP\\Connection $ldap, string $request_oid, string|null $request_data = null, array|null $controls = null, string $response_data = null, string $response_oid = null): LDAP\\Result|bool\nPerforms an extended operation',
'ldap_exop_whoami': '(LDAP\\Connection $ldap): string|false\nWHOAMI extended operation helper',
'ldap_exop': '(LDAP\\Connection $ldap, string $request_oid, string $request_data = null, array $controls = null, string $response_data = ?, string $response_oid = ?): mixed\nPerforms an extended operation',
'ldap_explode_dn': '(string $dn, int $with_attrib): array|false\nSplits DN into its component parts',
'ldap_first_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nReturn first attribute',
'ldap_first_entry': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first result id',
'ldap_first_reference': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first reference',
'ldap_free_result': '(LDAP\\Result $result): bool\nFree result memory',
'ldap_get_attributes': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): array\nGet attributes from a search result entry',
'ldap_get_dn': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the DN of a result entry',
'ldap_get_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): array|false\nGet all result entries',
'ldap_get_option': '(LDAP\\Connection $ldap, int $option, array|string|int $value = null): bool\nGet the current value for given option',
'ldap_get_values_len': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all binary values from a result entry',
'ldap_get_values': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all values from a result entry',
'ldap_list': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nSingle-level search',
'ldap_mod_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nAdd attribute values to current attributes',
'ldap_mod_add': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nAdd attribute values to current attributes',
'ldap_mod_del_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nDelete attribute values from current attributes',
'ldap_mod_del': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nDelete attribute values from current attributes',
'ldap_mod_replace_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nReplace attribute values with new ones',
'ldap_mod_replace': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nReplace attribute values with new ones',
'ldap_modify_batch': '(LDAP\\Connection $ldap, string $dn, array $modifications_info, array|null $controls = null): bool\nBatch and execute modifications on an LDAP entry',
'ldap_modify': 'Alias of ldap_mod_replace',
'ldap_next_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the next attribute in result',
'ldap_next_entry': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next result entry',
'ldap_next_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next reference',
'ldap_parse_exop': '(LDAP\\Connection $ldap, LDAP\\Result $result, string $response_data = null, string $response_oid = null): bool\nParse result object from an LDAP extended operation',
'ldap_parse_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, array $referrals): bool\nExtract information from reference entry',
'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): bool\nExtract information from result',
'ldap_read': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nRead an entry',
'ldap_rename_ext': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, array|null $controls = null): LDAP\\Result|false\nModify the name of an entry',
'ldap_rename': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, array|null $controls = null): bool\nModify the name of an entry',
'ldap_sasl_bind': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null, string|null $mech = null, string|null $realm = null, string|null $authc_id = null, string|null $authz_id = null, string|null $props = null): bool\nBind to LDAP directory using SASL',
'ldap_search': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nSearch LDAP tree',
'ldap_set_option': '(LDAP\\Connection|null $ldap, int $option, array|string|int|bool $value): bool\nSet the value of the given option',
'ldap_set_rebind_proc': '(LDAP\\Connection $ldap, callable|null $callback): bool\nSet a callback function to do re-binds on referral chasing',
'ldap_sort': '(resource $link, resource $result, string $sortfilter): bool\nSort LDAP result entries on the client side',
'ldap_start_tls': '(LDAP\\Connection $ldap): bool\nStart TLS',
'ldap_t61_to_8859': '(string $value): string|false\nTranslate t61 characters to 8859 characters',
'ldap_unbind': '(LDAP\\Connection $ldap): bool\nUnbind from LDAP directory',
'libxml_clear_errors': '(): void\nClear libxml error buffer',
'libxml_disable_entity_loader': '(bool $disable = true): bool\nDisable the ability to load external entities',
'libxml_get_errors': '(): array\nRetrieve array of errors',
'libxml_get_external_entity_loader': '(): callable|null\nGet the current external entity loader',
'libxml_get_last_error': '(): LibXMLError|false\nRetrieve last error from libxml',
'libxml_set_external_entity_loader': '(callable|null $resolver_function): bool\nChanges the default external entity loader',
'libxml_set_streams_context': '(resource $context): void\nSet the streams context for the next libxml document load or write',
'libxml_use_internal_errors': '(bool|null $use_errors = null): bool\nDisable libxml errors and allow user to fetch error information as needed',
'mysqli_connect': 'Alias of mysqli::__construct',
'mysqli::escape_string': 'Alias of mysqli_real_escape_string',
'mysqli_execute': 'Alias of mysqli_stmt_execute',
'mysqli_get_client_stats': '(): array\nReturns client per-process statistics',
'mysqli_get_links_stats': '(): array\nReturn information about open and cached links',
'mysqli_report': 'Alias of mysqli_driver->report_mode',
'mysqli::set_opt': 'Alias of mysqli_options',
'mysqli_affected_rows': '(mysqli $mysql): int|string\nGets the number of affected rows in a previous MySQL operation',
'mysqli::autocommit': '(bool $enable): bool\nTurns on or off auto-committing database modifications',
'mysqli_autocommit': '(mysqli $mysql, bool $enable): bool\nTurns on or off auto-committing database modifications',
'mysqli::begin_transaction': '(int $flags = ?, string|null $name = null): bool\nStarts a transaction',
'mysqli_begin_transaction': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nStarts a transaction',
'mysqli::change_user': '(string $username, string $password, string|null $database): bool\nChanges the user of the database connection',
'mysqli_change_user': '(mysqli $mysql, string $username, string $password, string|null $database): bool\nChanges the user of the database connection',
'mysqli::character_set_name': '(): string\nReturns the current character set of the database connection',
'mysqli_character_set_name': '(mysqli $mysql): string\nReturns the current character set of the database connection',
'mysqli::close': '(): true\nCloses a previously opened database connection',
'mysqli_close': '(mysqli $mysql): true\nCloses a previously opened database connection',
'mysqli::commit': '(int $flags = ?, string|null $name = null): bool\nCommits the current transaction',
'mysqli_commit': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nCommits the current transaction',
'mysqli_connect_errno': '(): int\nReturns the error code from last connect call',
'mysqli_connect_error': '(): string|null\nReturns a description of the last connection error',
'mysqli::connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null): bool\nOpen a new connection to the MySQL server',
'mysqli_connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null): mysqli|false\nOpen a new connection to the MySQL server',
'mysqli::debug': '(string $options): true\nPerforms debugging operations',
'mysqli_debug': '(string $options): true\nPerforms debugging operations',
'mysqli::dump_debug_info': '(): bool\nDump debugging information into the log',
'mysqli_dump_debug_info': '(mysqli $mysql): bool\nDump debugging information into the log',
'mysqli_errno': '(mysqli $mysql): int\nReturns the error code for the most recent function call',
'mysqli_error_list': '(mysqli $mysql): array\nReturns a list of errors from the last command executed',
'mysqli_error': '(mysqli $mysql): string\nReturns a string description of the last error',
'mysqli::execute_query': '(string $query, array|null $params = null): mysqli_result|bool\nPrepares, binds parameters, and executes SQL statement',
'mysqli_execute_query': '(mysqli $mysql, string $query, array|null $params = null): mysqli_result|bool\nPrepares, binds parameters, and executes SQL statement',
'mysqli_field_count': '(mysqli $mysql): int\nReturns the number of columns for the most recent query',
'mysqli::get_charset': '(): object|null\nReturns a character set object',
'mysqli_get_charset': '(mysqli $mysql): object|null\nReturns a character set object',
'mysqli::get_client_info': '(): string\nGet MySQL client info',
'mysqli_get_client_info': '(mysqli|null $mysql = null): string\nGet MySQL client info',
'mysqli_get_client_version': '(): int\nReturns the MySQL client version as an integer',
'mysqli::get_connection_stats': '(): array\nReturns statistics about the client connection',
'mysqli_get_connection_stats': '(mysqli $mysql): array\nReturns statistics about the client connection',
'mysqli_get_host_info': '(mysqli $mysql): string\nReturns a string representing the type of connection used',
'mysqli_get_proto_info': '(mysqli $mysql): int\nReturns the version of the MySQL protocol used',
'mysqli::get_server_info': '(): string\nReturns the version of the MySQL server',
'mysqli_get_server_info': '(mysqli $mysql): string\nReturns the version of the MySQL server',
'mysqli_get_server_version': '(mysqli $mysql): int\nReturns the version of the MySQL server as an integer',
'mysqli::get_warnings': '(): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_get_warnings': '(mysqli $mysql): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_info': '(mysqli $mysql): string|null\nRetrieves information about the most recently executed query',
'mysqli::init': '(): bool|null\nInitializes MySQLi and returns an object for use with mysqli_real_connect()',
'mysqli_init': '(): mysqli|false\nInitializes MySQLi and returns an object for use with mysqli_real_connect()',
'mysqli_insert_id': '(mysqli $mysql): int|string\nReturns the value generated for an AUTO_INCREMENT column by the last query',
'mysqli::kill': '(int $process_id): bool\nAsks the server to kill a MySQL thread',
'mysqli_kill': '(mysqli $mysql, int $process_id): bool\nAsks the server to kill a MySQL thread',
'mysqli::more_results': '(): bool\nCheck if there are any more query results from a multi query',
'mysqli_more_results': '(mysqli $mysql): bool\nCheck if there are any more query results from a multi query',
'mysqli::multi_query': '(string $query): bool\nPerforms one or more queries on the database',
'mysqli_multi_query': '(mysqli $mysql, string $query): bool\nPerforms one or more queries on the database',
'mysqli::next_result': '(): bool\nPrepare next result from multi_query',
'mysqli_next_result': '(mysqli $mysql): bool\nPrepare next result from multi_query',
'mysqli::options': '(int $option, string|int $value): bool\nSet options',
'mysqli_options': '(mysqli $mysql, int $option, string|int $value): bool\nSet options',
'mysqli::ping': '(): bool\nPings a server connection, or tries to reconnect if the connection has gone down',
'mysqli_ping': '(mysqli $mysql): bool\nPings a server connection, or tries to reconnect if the connection has gone down',
'mysqli::poll': '(array|null $read, array|null $error, array $reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
'mysqli_poll': '(array|null $read, array|null $error, array $reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
'mysqli::prepare': '(string $query): mysqli_stmt|false\nPrepares an SQL statement for execution',
'mysqli_prepare': '(mysqli $mysql, string $query): mysqli_stmt|false\nPrepares an SQL statement for execution',
'mysqli::query': '(string $query, int $result_mode = MYSQLI_STORE_RESULT): mysqli_result|bool\nPerforms a query on the database',
'mysqli_query': '(mysqli $mysql, string $query, int $result_mode = MYSQLI_STORE_RESULT): mysqli_result|bool\nPerforms a query on the database',
'mysqli::real_connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null, int $flags = ?): bool\nOpens a connection to a mysql server',
'mysqli_real_connect': '(mysqli $mysql, string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null, int $flags = ?): bool\nOpens a connection to a mysql server',
'mysqli::real_escape_string': '(string $string): string\nEscapes special characters in a string for use in an SQL statement, taking into account the current charset of the connection',
'mysqli_real_escape_string': '(mysqli $mysql, string $string): string\nEscapes special characters in a string for use in an SQL statement, taking into account the current charset of the connection',
'mysqli::real_query': '(string $query): bool\nExecute an SQL query',
'mysqli_real_query': '(mysqli $mysql, string $query): bool\nExecute an SQL query',
'mysqli::reap_async_query': '(): mysqli_result|bool\nGet result from async query',
'mysqli_reap_async_query': '(mysqli $mysql): mysqli_result|bool\nGet result from async query',
'mysqli::refresh': '(int $flags): bool\nRefreshes',
'mysqli_refresh': '(mysqli $mysql, int $flags): bool\nRefreshes',
'mysqli::release_savepoint': '(string $name): bool\nRemoves the named savepoint from the set of savepoints of the current transaction',
'mysqli_release_savepoint': '(mysqli $mysql, string $name): bool\nRemoves the named savepoint from the set of savepoints of the current transaction',
'mysqli::rollback': '(int $flags = ?, string|null $name = null): bool\nRolls back current transaction',
'mysqli_rollback': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nRolls back current transaction',
'mysqli::savepoint': '(string $name): bool\nSet a named transaction savepoint',
'mysqli_savepoint': '(mysqli $mysql, string $name): bool\nSet a named transaction savepoint',
'mysqli::select_db': '(string $database): bool\nSelects the default database for database queries',
'mysqli_select_db': '(mysqli $mysql, string $database): bool\nSelects the default database for database queries',
'mysqli::set_charset': '(string $charset): bool\nSets the client character set',
'mysqli_set_charset': '(mysqli $mysql, string $charset): bool\nSets the client character set',
'mysqli_sqlstate': '(mysqli $mysql): string\nReturns the SQLSTATE error from previous MySQL operation',
'mysqli::ssl_set': '(string|null $key, string|null $certificate, string|null $ca_certificate, string|null $ca_path, string|null $cipher_algos): true\nUsed for establishing secure connections using SSL',
'mysqli_ssl_set': '(mysqli $mysql, string|null $key, string|null $certificate, string|null $ca_certificate, string|null $ca_path, string|null $cipher_algos): true\nUsed for establishing secure connections using SSL',
'mysqli::stat': '(): string|false\nGets the current system status',
'mysqli_stat': '(mysqli $mysql): string|false\nGets the current system status',
'mysqli::stmt_init': '(): mysqli_stmt|false\nInitializes a statement and returns an object for use with mysqli_stmt_prepare',
'mysqli_stmt_init': '(mysqli $mysql): mysqli_stmt|false\nInitializes a statement and returns an object for use with mysqli_stmt_prepare',
'mysqli::store_result': '(int $mode = ?): mysqli_result|false\nTransfers a result set from the last query',
'mysqli_store_result': '(mysqli $mysql, int $mode = ?): mysqli_result|false\nTransfers a result set from the last query',
'mysqli_thread_id': '(mysqli $mysql): int\nReturns the thread ID for the current connection',
'mysqli::thread_safe': '(): bool\nReturns whether thread safety is given or not',
'mysqli_thread_safe': '(): bool\nReturns whether thread safety is given or not',
'mysqli::use_result': '(): mysqli_result|false\nInitiate a result set retrieval',
'mysqli_use_result': '(mysqli $mysql): mysqli_result|false\nInitiate a result set retrieval',
'mysqli_warning_count': '(mysqli $mysql): int\nReturns the number of warnings generated by the most recently executed query',
'mysqli_driver::embedded_server_end': '(): void\nStop embedded server',
'mysqli_embedded_server_end': '(): void\nStop embedded server',
'mysqli_driver::embedded_server_start': '(int $start, array $arguments, array $groups): bool\nInitialize and start embedded server',
'mysqli_embedded_server_start': '(int $start, array $arguments, array $groups): bool\nInitialize and start embedded server',
'mysqli_report': '(int $flags): true\nSets mysqli error reporting mode',
'mysqli_field_tell': '(mysqli_result $result): int\nGet current field offset of a result pointer',
'mysqli_result::data_seek': '(int $offset): bool\nAdjusts the result pointer to an arbitrary row in the result',
'mysqli_data_seek': '(mysqli_result $result, int $offset): bool\nAdjusts the result pointer to an arbitrary row in the result',
'mysqli_result::fetch_all': '(int $mode = MYSQLI_NUM): array\nFetch all result rows as an associative array, a numeric array, or both',
'mysqli_fetch_all': '(mysqli_result $result, int $mode = MYSQLI_NUM): array\nFetch all result rows as an associative array, a numeric array, or both',
'mysqli_result::fetch_array': '(int $mode = MYSQLI_BOTH): array|null|false\nFetch the next row of a result set as an associative, a numeric array, or both',
'mysqli_fetch_array': '(mysqli_result $result, int $mode = MYSQLI_BOTH): array|null|false\nFetch the next row of a result set as an associative, a numeric array, or both',
'mysqli_result::fetch_assoc': '(): array|null|false\nFetch the next row of a result set as an associative array',
'mysqli_fetch_assoc': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an associative array',
'mysqli_result::fetch_column': '(int $column = ?): null|int|float|string|false\nFetch a single column from the next row of a result set',
'mysqli_fetch_column': '(mysqli_result $result, int $column = ?): null|int|float|string|false\nFetch a single column from the next row of a result set',
'mysqli_result::fetch_field_direct': '(int $index): object|false\nFetch meta-data for a single field',
'mysqli_fetch_field_direct': '(mysqli_result $result, int $index): object|false\nFetch meta-data for a single field',
'mysqli_result::fetch_field': '(): object|false\nReturns the next field in the result set',
'mysqli_fetch_field': '(mysqli_result $result): object|false\nReturns the next field in the result set',
'mysqli_result::fetch_fields': '(): array\nReturns an array of objects representing the fields in a result set',
'mysqli_fetch_fields': '(mysqli_result $result): array\nReturns an array of objects representing the fields in a result set',
'mysqli_result::fetch_object': '(string $class = "stdClass", array $constructor_args = []): object|null|false\nFetch the next row of a result set as an object',
'mysqli_fetch_object': '(mysqli_result $result, string $class = "stdClass", array $constructor_args = []): object|null|false\nFetch the next row of a result set as an object',
'mysqli_result::fetch_row': '(): array|null|false\nFetch the next row of a result set as an enumerated array',
'mysqli_fetch_row': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an enumerated array',
'mysqli_num_fields': '(mysqli_result $result): int\nGets the number of fields in the result set',
'mysqli_result::field_seek': '(int $index): true\nSet result pointer to a specified field offset',
'mysqli_field_seek': '(mysqli_result $result, int $index): true\nSet result pointer to a specified field offset',
'mysqli_result::free': '(): void\nFrees the memory associated with a result',
'mysqli_result::close': '(): void\nFrees the memory associated with a result',
'mysqli_result::free_result': '(): void\nFrees the memory associated with a result',
'mysqli_free_result': '(mysqli_result $result): void\nFrees the memory associated with a result',
'mysqli_result::getIterator': '(): Iterator\nRetrieve an external iterator',
'mysqli_fetch_lengths': '(mysqli_result $result): array|false\nReturns the lengths of the columns of the current row in the result set',
'mysqli_num_rows': '(mysqli_result $result): int|string\nGets the number of rows in the result set',
'mysqli_sql_exception::getSqlState': '(): string\nReturns the SQLSTATE error code',
'mysqli_stmt_affected_rows': '(mysqli_stmt $statement): int|string\nReturns the total number of rows changed, deleted, inserted, or matched by the last statement executed',
'mysqli_stmt::attr_get': '(int $attribute): int\nUsed to get the current value of a statement attribute',
'mysqli_stmt_attr_get': '(mysqli_stmt $statement, int $attribute): int\nUsed to get the current value of a statement attribute',
'mysqli_stmt::attr_set': '(int $attribute, int $value): bool\nUsed to modify the behavior of a prepared statement',
'mysqli_stmt_attr_set': '(mysqli_stmt $statement, int $attribute, int $value): bool\nUsed to modify the behavior of a prepared statement',
'mysqli_stmt::bind_param': '(string $types, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement as parameters',
'mysqli_stmt_bind_param': '(mysqli_stmt $statement, string $types, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement as parameters',
'mysqli_stmt::bind_result': '(mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement for result storage',
'mysqli_stmt_bind_result': '(mysqli_stmt $statement, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement for result storage',
'mysqli_stmt::close': '(): true\nCloses a prepared statement',
'mysqli_stmt_close': '(mysqli_stmt $statement): true\nCloses a prepared statement',
'mysqli_stmt::data_seek': '(int $offset): void\nAdjusts the result pointer to an arbitrary row in the buffered result',
'mysqli_stmt_data_seek': '(mysqli_stmt $statement, int $offset): void\nAdjusts the result pointer to an arbitrary row in the buffered result',
'mysqli_stmt_errno': '(mysqli_stmt $statement): int\nReturns the error code for the most recent statement call',
'mysqli_stmt_error_list': '(mysqli_stmt $statement): array\nReturns a list of errors from the last statement executed',
'mysqli_stmt_error': '(mysqli_stmt $statement): string\nReturns a string description for last statement error',
'mysqli_stmt::execute': '(array|null $params = null): bool\nExecutes a prepared statement',
'mysqli_stmt_execute': '(mysqli_stmt $statement, array|null $params = null): bool\nExecutes a prepared statement',
'mysqli_stmt::fetch': '(): bool|null\nFetch results from a prepared statement into the bound variables',
'mysqli_stmt_fetch': '(mysqli_stmt $statement): bool|null\nFetch results from a prepared statement into the bound variables',
'mysqli_stmt_field_count': '(mysqli_stmt $statement): int\nReturns the number of columns in the given statement',
'mysqli_stmt::free_result': '(): void\nFrees stored result memory for the given statement handle',
'mysqli_stmt_free_result': '(mysqli_stmt $statement): void\nFrees stored result memory for the given statement handle',
'mysqli_stmt::get_result': '(): mysqli_result|false\nGets a result set from a prepared statement as a mysqli_result object',
'mysqli_stmt_get_result': '(mysqli_stmt $statement): mysqli_result|false\nGets a result set from a prepared statement as a mysqli_result object',
'mysqli_stmt::get_warnings': '(): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_stmt_get_warnings': '(mysqli_stmt $statement): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_stmt_insert_id': '(mysqli_stmt $statement): int|string\nGet the ID generated from the previous INSERT operation',
'mysqli_stmt::more_results': '(): bool\nCheck if there are more query results from a multiple query',
'mysqli_stmt_more_results': '(mysqli_stmt $statement): bool\nCheck if there are more query results from a multiple query',
'mysqli_stmt::next_result': '(): bool\nReads the next result from a multiple query',
'mysqli_stmt_next_result': '(mysqli_stmt $statement): bool\nReads the next result from a multiple query',
'mysqli_stmt::num_rows': '(): int|string\nReturns the number of rows fetched from the server',
'mysqli_stmt_num_rows': '(mysqli_stmt $statement): int|string\nReturns the number of rows fetched from the server',
'mysqli_stmt_param_count': '(mysqli_stmt $statement): int\nReturns the number of parameters for the given statement',
'mysqli_stmt::prepare': '(string $query): bool\nPrepares an SQL statement for execution',
'mysqli_stmt_prepare': '(mysqli_stmt $statement, string $query): bool\nPrepares an SQL statement for execution',
'mysqli_stmt::reset': '(): bool\nResets a prepared statement',
'mysqli_stmt_reset': '(mysqli_stmt $statement): bool\nResets a prepared statement',
'mysqli_stmt::result_metadata': '(): mysqli_result|false\nReturns result set metadata from a prepared statement',
'mysqli_stmt_result_metadata': '(mysqli_stmt $statement): mysqli_result|false\nReturns result set metadata from a prepared statement',
'mysqli_stmt::send_long_data': '(int $param_num, string $data): bool\nSend data in blocks',
'mysqli_stmt_send_long_data': '(mysqli_stmt $statement, int $param_num, string $data): bool\nSend data in blocks',
'mysqli_stmt_sqlstate': '(mysqli_stmt $statement): string\nReturns SQLSTATE error from previous statement operation',
'mysqli_stmt::store_result': '(): bool\nStores a result set in an internal buffer',
'mysqli_stmt_store_result': '(mysqli_stmt $statement): bool\nStores a result set in an internal buffer',
'mysqli_warning::next': '(): bool\nFetch next warning',
'openssl_cipher_iv_length': '(string $cipher_algo): int|false\nGets the cipher iv length',
'openssl_cipher_key_length': '(string $cipher_algo): int|false\nGets the cipher key length',
'openssl_cms_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nDecrypt a CMS message',
'openssl_cms_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, array|null $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt a CMS message',
'openssl_cms_read': '(string $input_filename, array $certificates): bool\nExport the CMS file to an array of PEM certificates',
'openssl_cms_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, array|null $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, string|null $untrusted_certificates_filename = null): bool\nSign a file',
'openssl_cms_verify': '(string $input_filename, int $flags = ?, string|null $certificates = null, array $ca_info = [], string|null $untrusted_certificates_filename = null, string|null $content = null, string|null $pk7 = null, string|null $sigfile = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nVerify a CMS signature',
'openssl_csr_export_to_file': '(OpenSSLCertificateSigningRequest|string $csr, string $output_filename, bool $no_text = true): bool\nExports a CSR to a file',
'openssl_csr_export': '(OpenSSLCertificateSigningRequest|string $csr, string $output, bool $no_text = true): bool\nExports a CSR as a string',
'openssl_csr_get_public_key': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): OpenSSLAsymmetricKey|false\nReturns the public key of a CSR',
'openssl_csr_get_subject': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): array|false\nReturns the subject of a CSR',
'openssl_csr_new': '(array $distinguished_names, OpenSSLAsymmetricKey|null $private_key, array|null $options = null, array|null $extra_attributes = null): OpenSSLCertificateSigningRequest|bool\nGenerates a CSR',
'openssl_csr_sign': '(OpenSSLCertificateSigningRequest|string $csr, OpenSSLCertificate|string|null $ca_certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $days, array|null $options = null, int $serial = ?, string|null $serial_hex = null): OpenSSLCertificate|false\nSign a CSR with another certificate (or itself) and generate a certificate',
'openssl_decrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", string|null $tag = null, string $aad = ""): string|false\nDecrypts data',
'openssl_dh_compute_key': '(string $public_key, OpenSSLAsymmetricKey $private_key): string|false\nComputes shared secret for public value of remote DH public key and local DH key',
'openssl_digest': '(string $data, string $digest_algo, bool $binary = false): string|false\nComputes a digest',
'openssl_encrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", string $tag = null, string $aad = "", int $tag_length = 16): string|false\nEncrypts data',
'openssl_error_string': '(): string|false\nReturn openSSL error message',
'openssl_free_key': '(OpenSSLAsymmetricKey $key): void\nFree key resource',
'openssl_get_cert_locations': '(): array\nRetrieve the available certificate locations',
'openssl_get_cipher_methods': '(bool $aliases = false): array\nGets available cipher methods',
'openssl_get_curve_names': '(): array|false\nGets list of available curve names for ECC',
'openssl_get_md_methods': '(bool $aliases = false): array\nGets available digest methods',
'openssl_get_privatekey': 'Alias of openssl_pkey_get_private',
'openssl_get_publickey': 'Alias of openssl_pkey_get_public',
'openssl_open': '(string $data, string $output, string $encrypted_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $cipher_algo, string|null $iv = null): bool\nOpen sealed data',
'openssl_pbkdf2': '(string $password, string $salt, int $key_length, int $iterations, string $digest_algo = "sha1"): string|false\nGenerates a PKCS5 v2 PBKDF2 string',
'openssl_pkcs12_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File',
'openssl_pkcs12_export': '(OpenSSLCertificate|string $certificate, string $output, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File to variable',
'openssl_pkcs12_read': '(string $pkcs12, array $certificates, string $passphrase): bool\nParse a PKCS#12 Certificate Store into an array',
'openssl_pkcs7_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null): bool\nDecrypts an S/MIME encrypted message',
'openssl_pkcs7_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, array|null $headers, int $flags = ?, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt an S/MIME message',
'openssl_pkcs7_read': '(string $data, array $certificates): bool\nExport the PKCS7 file to an array of PEM certificates',
'openssl_pkcs7_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, array|null $headers, int $flags = PKCS7_DETACHED, string|null $untrusted_certificates_filename = null): bool\nSign an S/MIME message',
'openssl_pkcs7_verify': '(string $input_filename, int $flags, string|null $signers_certificates_filename = null, array $ca_info = [], string|null $untrusted_certificates_filename = null, string|null $content = null, string|null $output_filename = null): bool|int\nVerifies the signature of an S/MIME signed message',
'openssl_pkey_derive': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $key_length = ?): string|false\nComputes shared secret for public value of remote and local DH or ECDH key',
'openssl_pkey_export_to_file': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string $output_filename, string|null $passphrase = null, array|null $options = null): bool\nGets an exportable representation of a key into a file',
'openssl_pkey_export': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string $output, string|null $passphrase = null, array|null $options = null): bool\nGets an exportable representation of a key into a string',
'openssl_pkey_free': '(OpenSSLAsymmetricKey $key): void\nFrees a private key',
'openssl_pkey_get_details': '(OpenSSLAsymmetricKey $key): array|false\nReturns an array with the key details',
'openssl_pkey_get_private': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string|null $passphrase = null): OpenSSLAsymmetricKey|false\nGet a private key',
'openssl_pkey_get_public': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): OpenSSLAsymmetricKey|false\nExtract public key from certificate and prepare it for use',
'openssl_pkey_new': '(array|null $options = null): OpenSSLAsymmetricKey|false\nGenerates a new private key',
'openssl_private_decrypt': '(string $data, string $decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nDecrypts data with private key',
'openssl_private_encrypt': '(string $data, string $encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nEncrypts data with private key',
'openssl_public_decrypt': '(string $data, string $decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nDecrypts data with public key',
'openssl_public_encrypt': '(string $data, string $encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nEncrypts data with public key',
'openssl_random_pseudo_bytes': '(int $length, bool $strong_result = null): string\nGenerate a pseudo-random string of bytes',
'openssl_seal': '(string $data, string $sealed_data, array $encrypted_keys, array $public_key, string $cipher_algo, string $iv = null): int|false\nSeal (encrypt) data',
'openssl_sign': '(string $data, string $signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string|int $algorithm = OPENSSL_ALGO_SHA1): bool\nGenerate signature',
'openssl_spki_export_challenge': '(string $spki): string|false\nExports the challenge associated with a signed public key and challenge',
'openssl_spki_export': '(string $spki): string|false\nExports a valid PEM formatted public key signed public key and challenge',
'openssl_spki_new': '(OpenSSLAsymmetricKey $private_key, string $challenge, int $digest_algo = OPENSSL_ALGO_MD5): string|false\nGenerate a new signed public key and challenge',
'openssl_spki_verify': '(string $spki): bool\nVerifies a signed public key and challenge',
'openssl_verify': '(string $data, string $signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, string|int $algorithm = OPENSSL_ALGO_SHA1): int|false\nVerify signature',
'openssl_x509_check_private_key': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key): bool\nChecks if a private key corresponds to a certificate',
'openssl_x509_checkpurpose': '(OpenSSLCertificate|string $certificate, int $purpose, array $ca_info = [], string|null $untrusted_certificates_file = null): bool|int\nVerifies if a certificate can be used for a particular purpose',
'openssl_x509_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, bool $no_text = true): bool\nExports a certificate to file',
'openssl_x509_export': '(OpenSSLCertificate|string $certificate, string $output, bool $no_text = true): bool\nExports a certificate as a string',
'openssl_x509_fingerprint': '(OpenSSLCertificate|string $certificate, string $digest_algo = "sha1", bool $binary = false): string|false\nCalculates the fingerprint, or digest, of a given X.509 certificate',
'openssl_x509_free': '(OpenSSLCertificate $certificate): void\nFree certificate resource',
'openssl_x509_parse': '(OpenSSLCertificate|string $certificate, bool $short_names = true): array|false\nParse an X509 certificate and return the information as an array',
'openssl_x509_read': '(OpenSSLCertificate|string $certificate): OpenSSLCertificate|false\nParse an X.509 certificate and return an object for it',
'openssl_x509_verify': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): int\nVerifies digital signature of x509 certificate against a public key',
'Pdo\\Firebird::getApiVersion': '(): int\nGet the API version',
'Pdo\\Mysql::getWarningCount': '(): int\nReturns the number of warnings from the last executed query',
'Pdo\\Pgsql::copyFromArray': '(string $tableName, array $rows, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from a PHP array into a table',
'Pdo\\Pgsql::copyFromFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from file into table',
'Pdo\\Pgsql::copyToArray': '(string $tableName, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): array|false\nCopy data from database table into PHP array',
'Pdo\\Pgsql::copyToFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from table into file',
'Pdo\\Pgsql::escapeIdentifier': '(string $input): string\nEscapes a string for use as an SQL identifier',
'Pdo\\Pgsql::getNotify': '(int $fetchMode = PDO::FETCH_DEFAULT, int $timeoutMilliseconds = ?): array|false\nGet asynchronous notification',
'Pdo\\Pgsql::getPid': '(): int\nGet the PID of the backend process handling this connection',
'Pdo\\Pgsql::lobCreate': '(): string|false\nCreates a new large object',
'Pdo\\Pgsql::lobOpen': '(string $oid, string $mode = "rb"): resource|false\nOpens an existing large object stream',
'Pdo\\Pgsql::lobUnlink': '(string $oid): bool\nDeletes the large object',
'Pdo\\Pgsql::setNoticeCallback': '(callable|null $callback): void\nSet a callback to handle notice and warning messages generated by the backend',
'PDO::pgsqlCopyFromArray': '(string $tableName, array $rows, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyFromArray',
'PDO::pgsqlCopyFromFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyFromFile',
'PDO::pgsqlCopyToArray': '(string $tableName, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): array|false\nAlias Pdo\\Pgsql::copyToArray',
'PDO::pgsqlCopyToFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyToFile',
'PDO::pgsqlGetNotify': '(int $fetchMode = PDO::FETCH_DEFAULT, int $timeoutMilliseconds = ?): array|false\nAlias Pdo\\Pgsql::getNotify',
'PDO::pgsqlGetPid': '(): int\nAlias Pdo\\Pgsql::getPid',
'PDO::pgsqlLOBCreate': '(): string\nAlias Pdo\\Pgsql::lobCreate',
'PDO::pgsqlLOBOpen': '(string $oid, string $mode = "rb"): resource|false\nAlias Pdo\\Pgsql::lobOpen',
'PDO::pgsqlLOBUnlink': '(string $oid): bool\nAlias Pdo\\Pgsql::lobUnlink',
'Pdo\\Sqlite::createAggregate': '(string $name, callable $step, callable $finalize, int $numArgs = -1): bool\nRegisters an aggregating user-defined function for use in SQL statements',
'Pdo\\Sqlite::createCollation': '(string $name, callable $callback): bool\nRegisters a user-defined function for use as a collating function in SQL statements',
'Pdo\\Sqlite::createFunction': '(string $function_name, callable $callback, int $num_args = -1, int $flags = ?): bool\nRegisters a user-defined function for use in SQL statements',
'Pdo\\Sqlite::loadExtension': '(string $name): void\nDescription',
'Pdo\\Sqlite::openBlob': '(string $table, string $column, int $rowid, string|null $dbname = "main", int $flags = Pdo\\Sqlite::OPEN_READONLY): resource|false\nDescription',
'PDO::sqliteCreateAggregate': '(string $name, callable $step, callable $finalize, int $numArgs = -1): bool\nAlias Pdo\\Sqlite::createAggregate',
'PDO::sqliteCreateCollation': '(string $name, callable $callback): bool\nAlias Pdo\\Sqlite::createCollation',
'PDO::sqliteCreateFunction': '(string $function_name, callable $callback, int $num_args = -1, int $flags = ?): bool\nAlias Pdo\\Sqlite::createFunction',
'pg_affected_rows': '(PgSql\\Result $result): int\nReturns number of affected records (tuples)',
'pg_cancel_query': '(PgSql\\Connection $connection): bool\nCancel an asynchronous query',
'pg_client_encoding': '(PgSql\\Connection|null $connection = null): string\nGets the client encoding',
'pg_close': '(PgSql\\Connection|null $connection = null): true\nCloses a PostgreSQL connection',
'pg_connect_poll': '(PgSql\\Connection $connection): int\nPoll the status of an in-progress asynchronous PostgreSQL connection attempt',
'pg_connect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a PostgreSQL connection',
'pg_connection_busy': '(PgSql\\Connection $connection): bool\nGet connection is busy or not',
'pg_connection_reset': '(PgSql\\Connection $connection): bool\nReset connection (reconnect)',
'pg_connection_status': '(PgSql\\Connection $connection): int\nGet connection status',
'pg_consume_input': '(PgSql\\Connection $connection): bool\nReads input on the connection',
'pg_convert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = ?): array|false\nConvert associative array values into forms suitable for SQL statements',
'pg_copy_from': '(PgSql\\Connection $connection, string $table_name, array $rows, string $separator = "\\t", string $null_as = "\\\\\\\\N"): bool\nInsert records into a table from an array',
'pg_copy_to': '(PgSql\\Connection $connection, string $table_name, string $separator = "\\t", string $null_as = "\\\\\\\\N"): array|false\nCopy a table to an array',
'pg_dbname': '(PgSql\\Connection|null $connection = null): string\nGet the database name',
'pg_delete': '(PgSql\\Connection $connection, string $table_name, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nDeletes records',
'pg_end_copy': '(PgSql\\Connection|null $connection = null): bool\nSync with PostgreSQL backend',
'pg_escape_bytea': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a string for insertion into a bytea field',
'pg_escape_identifier': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a identifier for insertion into a text field',
'pg_escape_literal': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a literal for insertion into a text field',
'pg_escape_string': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a string for query',
'pg_execute': '(PgSql\\Connection $connection = ?, string $stmtname, array $params): PgSql\\Result|false\nSends a request to execute a prepared statement with given parameters, and waits for the result',
'pg_fetch_all_columns': '(PgSql\\Result $result, int $field = ?): array\nFetches all rows in a particular result column as an array',
'pg_fetch_all': '(PgSql\\Result $result, int $mode = PGSQL_ASSOC): array\nFetches all rows from a result as an array',
'pg_fetch_array': '(PgSql\\Result $result, int|null $row = null, int $mode = PGSQL_BOTH): array|false\nFetch a row as an array',
'pg_fetch_assoc': '(PgSql\\Result $result, int|null $row = null): array|false\nFetch a row as an associative array',
'pg_fetch_object': '(PgSql\\Result $result, int|null $row = null, string $class = "stdClass", array $constructor_args = []): object|false\nFetch a row as an object',
'pg_fetch_result': '(PgSql\\Result $result, string|false|null $row, mixed $field): string|false|null\nReturns values from a result instance',
'pg_fetch_result': '(PgSql\\Result $result, mixed $field): string|false|null\nReturns values from a result instance',
'pg_fetch_row': '(PgSql\\Result $result, int|null $row = null, int $mode = PGSQL_NUM): array|false\nGet a row as an enumerated array',
'pg_field_is_null': '(PgSql\\Result $result, string|false|null $row, mixed $field): int\nTest if a field is SQL NULL',
'pg_field_is_null': '(PgSql\\Result $result, mixed $field): int\nTest if a field is SQL NULL',
'pg_field_name': '(PgSql\\Result $result, int $field): string\nReturns the name of a field',
'pg_field_num': '(PgSql\\Result $result, string $field): int\nReturns the field number of the named field',
'pg_field_prtlen': '(PgSql\\Result $result, string|false|null $row, mixed $field_name_or_number): int\nReturns the printed length',
'pg_field_prtlen': '(PgSql\\Result $result, mixed $field_name_or_number): int\nReturns the printed length',
'pg_field_size': '(PgSql\\Result $result, int $field): int\nReturns the internal storage size of the named field',
'pg_field_table': '(PgSql\\Result $result, int $field, bool $oid_only = false): string|int|false\nReturns the name or oid of the tables field',
'pg_field_type_oid': '(PgSql\\Result $result, int $field): string|int\nReturns the type ID (OID) for the corresponding field number',
'pg_field_type': '(PgSql\\Result $result, int $field): string\nReturns the type name for the corresponding field number',
'pg_flush': '(PgSql\\Connection $connection): int|bool\nFlush outbound query data on the connection',
'pg_free_result': '(PgSql\\Result $result): bool\nFree result memory',
'pg_get_notify': '(PgSql\\Connection $connection, int $mode = PGSQL_ASSOC): array|false\nGets SQL NOTIFY message',
'pg_get_pid': '(PgSql\\Connection $connection): int\nGets the backend\'s process ID',
'pg_get_result': '(PgSql\\Connection $connection): PgSql\\Result|false\nGet asynchronous query result',
'pg_host': '(PgSql\\Connection|null $connection = null): string\nReturns the host name associated with the connection',
'pg_insert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = PGSQL_DML_EXEC): PgSql\\Result|string|bool\nInsert array into table',
'pg_last_error': '(PgSql\\Connection|null $connection = null): string\nGet the last error message string of a connection',
'pg_last_notice': '(PgSql\\Connection $connection, int $mode = PGSQL_NOTICE_LAST): array|string|bool\nReturns the last notice message from PostgreSQL server',
'pg_last_oid': '(PgSql\\Result $result): string|int|false\nReturns the last row\'s OID',
'pg_lo_close': '(PgSql\\Lob $lob): bool\nClose a large object',
'pg_lo_create': '(PgSql\\Connection $connection = ?, mixed $object_id = ?): int\nCreate a large object',
'pg_lo_create': '(mixed $object_id): int\nCreate a large object',
'pg_lo_export': '(PgSql\\Connection $connection = ?, int $oid, string $pathname): bool\nExport a large object to file',
'pg_lo_import': '(PgSql\\Connection $connection = ?, string $pathname, mixed $object_id = ?): int\nImport a large object from file',
'pg_lo_open': '(PgSql\\Connection $connection, int $oid, string $mode): PgSql\\Lob|false\nOpen a large object',
'pg_lo_read_all': '(PgSql\\Lob $lob): int\nReads an entire large object and send straight to browser',
'pg_lo_read': '(PgSql\\Lob $lob, int $length = 8192): string|false\nRead a large object',
'pg_lo_seek': '(PgSql\\Lob $lob, int $offset, int $whence = SEEK_CUR): bool\nSeeks position within a large object',
'pg_lo_tell': '(PgSql\\Lob $lob): int\nReturns current seek position a of large object',
'pg_lo_truncate': '(PgSql\\Lob $lob, int $size): bool\nTruncates a large object',
'pg_lo_unlink': '(PgSql\\Connection $connection, int $oid): bool\nDelete a large object',
'pg_lo_write': '(PgSql\\Lob $lob, string $data, int|null $length = null): int|false\nWrite to a large object',
'pg_meta_data': '(PgSql\\Connection $connection, string $table_name, bool $extended = false): array|false\nGet meta data for table',
'pg_num_fields': '(PgSql\\Result $result): int\nReturns the number of fields in a result',
'pg_num_rows': '(PgSql\\Result $result): int\nReturns the number of rows in a result',
'pg_options': '(PgSql\\Connection|null $connection = null): string\nGet the options associated with the connection',
'pg_parameter_status': '(PgSql\\Connection $connection = ?, string $param_name): string\nLooks up a current parameter setting of the server',
'pg_pconnect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a persistent PostgreSQL connection',
'pg_ping': '(PgSql\\Connection|null $connection = null): bool\nPing database connection',
'pg_port': '(PgSql\\Connection|null $connection = null): string\nReturn the port number associated with the connection',
'pg_prepare': '(PgSql\\Connection $connection = ?, string $stmtname, string $query): PgSql\\Result|false\nSubmits a request to the server to create a prepared statement with the given parameters, and waits for completion',
'pg_put_line': '(PgSql\\Connection $connection = ?, string $data): bool\nSend a NULL-terminated string to PostgreSQL backend',
'pg_query_params': '(PgSql\\Connection $connection = ?, string $query, array $params): PgSql\\Result|false\nSubmits a command to the server and waits for the result, with the ability to pass parameters separately from the SQL command text',
'pg_query': '(PgSql\\Connection $connection = ?, string $query): PgSql\\Result|false\nExecute a query',
'pg_result_error_field': '(PgSql\\Result $result, int $field_code): string|false|null\nReturns an individual field of an error report',
'pg_result_error': '(PgSql\\Result $result): string|false\nGet error message associated with result',
'pg_result_memory_size': '(PgSql\\Result $result): int\nReturns the amount of memory allocated for a query result',
'pg_result_seek': '(PgSql\\Result $result, int $row): bool\nSet internal row offset in result instance',
'pg_result_status': '(PgSql\\Result $result, int $mode = PGSQL_STATUS_LONG): string|int\nGet status of query result',
'pg_select': '(PgSql\\Connection $connection, string $table_name, array $conditions = [], int $flags = PGSQL_DML_EXEC, int $mode = PGSQL_ASSOC): array|string|false\nSelect records',
'pg_send_execute': '(PgSql\\Connection $connection, string $statement_name, array $params): int|bool\nSends a request to execute a prepared statement with given parameters, without waiting for the result(s)',
'pg_send_prepare': '(PgSql\\Connection $connection, string $statement_name, string $query): int|bool\nSends a request to create a prepared statement with the given parameters, without waiting for completion',
'pg_send_query_params': '(PgSql\\Connection $connection, string $query, array $params): int|bool\nSubmits a command and separate parameters to the server without waiting for the result(s)',
'pg_send_query': '(PgSql\\Connection $connection, string $query): int|bool\nSends asynchronous query',
'pg_set_chunked_rows_size': '(PgSql\\Connection $connection, int $size): bool\nSet the query results to be retrieved in chunk mode',
'pg_set_client_encoding': '(PgSql\\Connection $connection = ?, string $encoding): int\nSet the client encoding',
'pg_set_error_context_visibility': '(PgSql\\Connection $connection, int $visibility): int\nDetermines the visibility of the context\'s error messages returned by pg_last_error and pg_result_error',
'pg_set_error_verbosity': '(PgSql\\Connection $connection = ?, int $verbosity): int\nDetermines the verbosity of messages returned by pg_last_error and pg_result_error',
'pg_socket': '(PgSql\\Connection $connection): resource|false\nGet a read only handle to the socket underlying a PostgreSQL connection',
'pg_trace': '(string $filename, string $mode = "w", PgSql\\Connection|null $connection = null, int $trace_mode = ?): bool\nEnable tracing a PostgreSQL connection',
'pg_transaction_status': '(PgSql\\Connection $connection): int\nReturns the current in-transaction status of the server',
'pg_tty': '(PgSql\\Connection|null $connection = null): string\nReturn the TTY name associated with the connection',
'pg_unescape_bytea': '(string $string): string\nUnescape binary for bytea type',
'pg_untrace': '(PgSql\\Connection|null $connection = null): true\nDisable tracing of a PostgreSQL connection',
'pg_update': '(PgSql\\Connection $connection, string $table_name, array $values, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nUpdate table',
'pg_version': '(PgSql\\Connection|null $connection = null): array\nReturns an array with client, protocol and server version (when available)',
'readline_add_history': '(string $prompt): true\nAdds a line to the history',
'readline_callback_handler_install': '(string $prompt, callable $callback): true\nInitializes the readline callback interface and terminal, prints the prompt and returns immediately',
'readline_callback_handler_remove': '(): bool\nRemoves a previously installed callback handler and restores terminal settings',
'readline_callback_read_char': '(): void\nReads a character and informs the readline callback interface when a line is received',
'readline_clear_history': '(): true\nClears the history',
'readline_completion_function': '(callable $callback): bool\nRegisters a completion function',
'readline_info': '(string|null $var_name = null, int|string|bool|null $value = null): mixed\nGets/sets various internal readline variables',
'readline_list_history': '(): array\nLists the history',
'readline_on_new_line': '(): void\nInform readline that the cursor has moved to a new line',
'readline_read_history': '(string|null $filename = null): bool\nReads the history',
'readline_redisplay': '(): void\nRedraws the display',
'readline_write_history': '(string|null $filename = null): bool\nWrites the history',
'readline': '(string|null $prompt = null): string|false\nReads a line',
'simplexml_import_dom': '(object $node, string|null $class_name = SimpleXMLElement::class): SimpleXMLElement|null\nGet a SimpleXMLElement object from an XML or HTML node',
'simplexml_load_file': '(string $filename, string|null $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets an XML file into an object',
'simplexml_load_string': '(string $data, string|null $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets a string of XML into an object',
'SimpleXMLElement::addAttribute': '(string $qualifiedName, string $value, string|null $namespace = null): void\nAdds an attribute to the SimpleXML element',
'SimpleXMLElement::addChild': '(string $qualifiedName, string|null $value = null, string|null $namespace = null): SimpleXMLElement|null\nAdds a child element to the XML node',
'SimpleXMLElement::asXML': '(string|null $filename = null): string|bool\nReturn a well-formed XML string based on SimpleXML element',
'SimpleXMLElement::attributes': '(string|null $namespaceOrPrefix = null, bool $isPrefix = false): SimpleXMLElement|null\nIdentifies an element\'s attributes',
'SimpleXMLElement::children': '(string|null $namespaceOrPrefix = null, bool $isPrefix = false): SimpleXMLElement|null\nFinds children of given node',
'SimpleXMLElement::count': '(): int\nCounts the children of an element',
'SimpleXMLElement::current': '(): SimpleXMLElement\nReturns the current element',
'SimpleXMLElement::getDocNamespaces': '(bool $recursive = false, bool $fromRoot = true): array|false\nReturns namespaces declared in document',
'SimpleXMLElement::getName': '(): string\nGets the name of the XML element',
'SimpleXMLElement::getNamespaces': '(bool $recursive = false): array\nReturns namespaces used in document',
'SimpleXMLElement::getChildren': '(): SimpleXMLElement|null\nReturns the sub-elements of the current element',
'SimpleXMLElement::hasChildren': '(): bool\nChecks whether the current element has sub elements',
'SimpleXMLElement::key': '(): string\nReturn current key',
'SimpleXMLElement::next': '(): void\nMove to next element',
'SimpleXMLElement::registerXPathNamespace': '(string $prefix, string $namespace): bool\nCreates a prefix/ns context for the next XPath query',
'SimpleXMLElement::rewind': '(): void\nRewind to the first element',
'SimpleXMLElement::saveXML': 'Alias of SimpleXMLElement::asXML',
'SimpleXMLElement::__toString': '(): string\nReturns the string content',
'SimpleXMLElement::valid': '(): bool\nCheck whether the current element is valid',
'SimpleXMLElement::xpath': '(string $expression): array|null|false\nRuns XPath query on XML data',
'snmp_get_quick_print': '(): bool\nFetches the current value of the NET-SNMP library\'s quick_print setting',
'snmp_get_valueretrieval': '(): int\nReturn the method how the SNMP values will be returned',
'snmp_read_mib': '(string $filename): bool\nReads and parses a MIB file into the active MIB tree',
'snmp_set_enum_print': '(bool $enable): true\nReturn all values that are enums with their enum value instead of the raw integer',
'snmp_set_oid_numeric_print': 'Alias of snmp_set_oid_output_format',
'snmp_set_oid_output_format': '(int $format): true\nSet the OID output format',
'snmp_set_quick_print': '(bool $enable): true\nSet the value of $enable within the NET-SNMP library',
'snmp_set_valueretrieval': '(int $method): true\nSpecify the method how the SNMP values will be returned',
'snmp2_get': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmp2_getnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmp2_real_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmp2_set': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmp2_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmp3_get': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmp3_getnext': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmp3_real_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmp3_set': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmp3_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmpget': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmpgetnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmprealwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmpset': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmpwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmpwalkoid': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nQuery for a tree of information about a network entity',
'SNMP::close': '(): bool\nClose SNMP session',
'SNMP::get': '(array|string $objectId, bool $preserveKeys = false): mixed\nFetch an SNMP object',
'SNMP::getErrno': '(): int\nGet last error code',
'SNMP::getError': '(): string\nGet last error message',
'SNMP::getnext': '(array|string $objectId): mixed\nFetch an SNMP object which follows the given object id',
'SNMP::set': '(array|string $objectId, array|string $type, array|string $value): bool\nSet the value of an SNMP object',
'SNMP::setSecurity': '(string $securityLevel, string $authProtocol = "", string $authPassphrase = "", string $privacyProtocol = "", string $privacyPassphrase = "", string $contextName = "", string $contextEngineId = ""): bool\nConfigures security-related SNMPv3 session parameters',
'SNMP::walk': '(array|string $objectId, bool $suffixAsKey = false, int $maxRepetitions = -1, int $nonRepeaters = -1): array|false\nFetch SNMP object subtree',
'is_soap_fault': '(mixed $object): bool\nChecks if a SOAP call has failed',
'use_soap_error_handler': '(bool $enable = true): bool\nSet whether to use the SOAP error handler',
'SoapClient::__call': '(string $name, array $args): mixed\nCalls a SOAP function (deprecated)',
'SoapClient::__doRequest': '(string $request, string $location, string $action, int $version, bool $oneWay = false): string|null\nPerforms a SOAP request',
'SoapClient::__getCookies': '(): array\nGet list of cookies',
'SoapClient::__getFunctions': '(): array|null\nReturns list of available SOAP functions',
'SoapClient::__getLastRequest': '(): string|null\nReturns last SOAP request',
'SoapClient::__getLastRequestHeaders': '(): string|null\nReturns the SOAP headers from the last request',
'SoapClient::__getLastResponse': '(): string|null\nReturns last SOAP response',
'SoapClient::__getLastResponseHeaders': '(): string|null\nReturns the SOAP headers from the last response',
'SoapClient::__getTypes': '(): array|null\nReturns a list of SOAP types',
'SoapClient::__setCookie': '(string $name, string|null $value = null): void\nDefines a cookie for SOAP requests',
'SoapClient::__setLocation': '(string|null $location = null): string|null\nSets the location of the Web service to use',
'SoapClient::__setSoapHeaders': '(SoapHeader|array|null $headers = null): bool\nSets SOAP headers for subsequent calls',
'SoapClient::__soapCall': '(string $name, array $args, array|null $options = null, SoapHeader|array|null $inputHeaders = null, array $outputHeaders = null): mixed\nCalls a SOAP function',
'SoapFault::__toString': '(): string\nObtain a string representation of a SoapFault',
'SoapServer::addFunction': '(array|string|int $functions): void\nAdds one or more functions to handle SOAP requests',
'SoapServer::addSoapHeader': '(SoapHeader $header): void\nAdd a SOAP header to the response',
'SoapServer::fault': '(string $code, string $string, string $actor = "", mixed $details = null, string $name = ""): void\nIssue SoapServer fault indicating an error',
'SoapServer::getFunctions': '(): array\nReturns list of defined functions',
'SoapServer::__getLastResponse': '(): string|null\nReturns last SOAP response',
'SoapServer::handle': '(string|null $request = null): void\nHandles a SOAP request',
'SoapServer::setClass': '(string $class, mixed ...$args): void\nSets the class which handles SOAP requests',
'SoapServer::setObject': '(object $object): void\nSets the object which will be used to handle SOAP requests',
'SoapServer::setPersistence': '(int $mode): void\nSets SoapServer persistence mode',
'sodium_add': '(string $string1, string $string2): void\nAdd large numbers',
'sodium_base642bin': '(string $string, int $id, string $ignore = ""): string\nDecodes a base64-encoded string into raw binary.',
'sodium_bin2base64': '(string $string, int $id): string\nEncodes a raw binary string with base64.',
'sodium_bin2hex': '(string $string): string\nEncode to hexadecimal',
'sodium_compare': '(string $string1, string $string2): int\nCompare large numbers',
'sodium_crypto_aead_aegis128l_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-128L',
'sodium_crypto_aead_aegis128l_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-128L',
'sodium_crypto_aead_aegis128l_keygen': '(): string\nGenerate a random AEGIS-128L key',
'sodium_crypto_aead_aegis256_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-256',
'sodium_crypto_aead_aegis256_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-256',
'sodium_crypto_aead_aegis256_keygen': '(): string\nGenerate a random AEGIS-256 key',
'sodium_crypto_aead_aes256gcm_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AES-256-GCM',
'sodium_crypto_aead_aes256gcm_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with AES-256-GCM',
'sodium_crypto_aead_aes256gcm_is_available': '(): bool\nCheck if hardware supports AES256-GCM',
'sodium_crypto_aead_aes256gcm_keygen': '(): string\nGenerate a random AES-256-GCM key',
'sodium_crypto_aead_chacha20poly1305_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt with ChaCha20-Poly1305',
'sodium_crypto_aead_chacha20poly1305_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with ChaCha20-Poly1305',
'sodium_crypto_aead_chacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify that the ciphertext includes a valid tag',
'sodium_crypto_aead_chacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt a message',
'sodium_crypto_aead_chacha20poly1305_ietf_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 (IETF) key.',
'sodium_crypto_aead_chacha20poly1305_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 key.',
'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\n(Preferred) Verify then decrypt with XChaCha20-Poly1305',
'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\n(Preferred) Encrypt then authenticate with XChaCha20-Poly1305',
'sodium_crypto_aead_xchacha20poly1305_ietf_keygen': '(): string\nGenerate a random XChaCha20-Poly1305 key.',
'sodium_crypto_auth_keygen': '(): string\nGenerate a random key for sodium_crypto_auth',
'sodium_crypto_auth_verify': '(string $mac, string $message, string $key): bool\nVerifies that the tag is valid for the message',
'sodium_crypto_auth': '(string $message, string $key): string\nCompute a tag for the message',
'sodium_crypto_box_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nCreate a unified keypair string from a secret key and public key',
'sodium_crypto_box_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
'sodium_crypto_box_open': '(string $ciphertext, string $nonce, string $key_pair): string|false\nAuthenticated public-key decryption',
'sodium_crypto_box_publickey_from_secretkey': '(string $secret_key): string\nCalculate the public key from a secret key',
'sodium_crypto_box_publickey': '(string $key_pair): string\nExtract the public key from a crypto_box keypair',
'sodium_crypto_box_seal_open': '(string $ciphertext, string $key_pair): string|false\nAnonymous public-key decryption',
'sodium_crypto_box_seal': '(string $message, string $public_key): string\nAnonymous public-key encryption',
'sodium_crypto_box_secretkey': '(string $key_pair): string\nExtracts the secret key from a crypto_box keypair',
'sodium_crypto_box_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
'sodium_crypto_box': '(string $message, string $nonce, string $key_pair): string\nAuthenticated public-key encryption',
'sodium_crypto_core_ristretto255_add': '(string $p, string $q): string\nAdds an element',
'sodium_crypto_core_ristretto255_from_hash': '(string $s): string\nMaps a vector',
'sodium_crypto_core_ristretto255_is_valid_point': '(string $s): bool\nDetermines if a point on the ristretto255 curve',
'sodium_crypto_core_ristretto255_random': '(): string\nGenerates a random key',
'sodium_crypto_core_ristretto255_scalar_add': '(string $x, string $y): string\nAdds a scalar value',
'sodium_crypto_core_ristretto255_scalar_complement': '(string $s): string\nThe sodium_crypto_core_ristretto255_scalar_complement purpose',
'sodium_crypto_core_ristretto255_scalar_invert': '(string $s): string\nInverts a scalar value',
'sodium_crypto_core_ristretto255_scalar_mul': '(string $x, string $y): string\nMultiplies a scalar value',
'sodium_crypto_core_ristretto255_scalar_negate': '(string $s): string\nNegates a scalar value',
'sodium_crypto_core_ristretto255_scalar_random': '(): string\nGenerates a random key',
'sodium_crypto_core_ristretto255_scalar_reduce': '(string $s): string\nReduces a scalar value',
'sodium_crypto_core_ristretto255_scalar_sub': '(string $x, string $y): string\nSubtracts a scalar value',
'sodium_crypto_core_ristretto255_sub': '(string $p, string $q): string\nSubtracts an element',
'sodium_crypto_generichash_final': '(string $state, int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nComplete the hash',
'sodium_crypto_generichash_init': '(string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nInitialize a hash for streaming',
'sodium_crypto_generichash_keygen': '(): string\nGenerate a random generichash key',
'sodium_crypto_generichash_update': '(string $state, string $message): true\nAdd message to a hash',
'sodium_crypto_generichash': '(string $message, string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nGet a hash of the message',
'sodium_crypto_kdf_derive_from_key': '(int $subkey_length, int $subkey_id, string $context, string $key): string\nDerive a subkey',
'sodium_crypto_kdf_keygen': '(): string\nGenerate a random root key for the KDF interface',
'sodium_crypto_kx_client_session_keys': '(string $client_key_pair, string $server_key): array\nCalculate the client-side session keys.',
'sodium_crypto_kx_keypair': '(): string\nCreates a new sodium keypair',
'sodium_crypto_kx_publickey': '(string $key_pair): string\nExtract the public key from a crypto_kx keypair',
'sodium_crypto_kx_secretkey': '(string $key_pair): string\nExtract the secret key from a crypto_kx keypair.',
'sodium_crypto_kx_seed_keypair': '(string $seed): string\nDescription',
'sodium_crypto_kx_server_session_keys': '(string $server_key_pair, string $client_key): array\nCalculate the server-side session keys.',
'sodium_crypto_pwhash_scryptsalsa208sha256_str_verify': '(string $hash, string $password): bool\nVerify that the password is a valid password verification string',
'sodium_crypto_pwhash_scryptsalsa208sha256_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII encoded hash',
'sodium_crypto_pwhash_scryptsalsa208sha256': '(int $length, string $password, string $salt, int $opslimit, int $memlimit): string\nDerives a key from a password, using scrypt',
'sodium_crypto_pwhash_str_needs_rehash': '(string $password, int $opslimit, int $memlimit): bool\nDetermine whether or not to rehash a password',
'sodium_crypto_pwhash_str_verify': '(string $hash, string $password): bool\nVerifies that a password matches a hash',
'sodium_crypto_pwhash_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII-encoded hash',
'sodium_crypto_pwhash': '(int $length, string $password, string $salt, int $opslimit, int $memlimit, int $algo = SODIUM_CRYPTO_PWHASH_ALG_DEFAULT): string\nDerive a key from a password, using Argon2',
'sodium_crypto_scalarmult_base': 'Alias of sodium_crypto_box_publickey_from_secretkey',
'sodium_crypto_scalarmult_ristretto255_base': '(string $n): string\nCalculates the public key from a secret key',
'sodium_crypto_scalarmult_ristretto255': '(string $n, string $p): string\nComputes a shared secret',
'sodium_crypto_scalarmult': '(string $n, string $p): string\nCompute a shared secret given a user\'s secret key and another user\'s public key',
'sodium_crypto_secretbox_keygen': '(): string\nGenerate random key for sodium_crypto_secretbox',
'sodium_crypto_secretbox_open': '(string $ciphertext, string $nonce, string $key): string|false\nAuthenticated shared-key decryption',
'sodium_crypto_secretbox': '(string $message, string $nonce, string $key): string\nAuthenticated shared-key encryption',
'sodium_crypto_secretstream_xchacha20poly1305_init_pull': '(string $header, string $key): string\nInitialize a secretstream context for decryption',
'sodium_crypto_secretstream_xchacha20poly1305_init_push': '(string $key): array\nInitialize a secretstream context for encryption',
'sodium_crypto_secretstream_xchacha20poly1305_keygen': '(): string\nGenerate a random secretstream key.',
'sodium_crypto_secretstream_xchacha20poly1305_pull': '(string $state, string $ciphertext, string $additional_data = ""): array|false\nDecrypt a chunk of data from an encrypted stream',
'sodium_crypto_secretstream_xchacha20poly1305_push': '(string $state, string $message, string $additional_data = "", int $tag = SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_MESSAGE): string\nEncrypt a chunk of data so that it can safely be decrypted in a streaming API',
'sodium_crypto_secretstream_xchacha20poly1305_rekey': '(string $state): void\nExplicitly rotate the key in the secretstream state',
'sodium_crypto_shorthash_keygen': '(): string\nGet random bytes for key',
'sodium_crypto_shorthash': '(string $message, string $key): string\nCompute a short hash of a message and key',
'sodium_crypto_sign_detached': '(string $message, string $secret_key): string\nSign the message',
'sodium_crypto_sign_ed25519_pk_to_curve25519': '(string $public_key): string\nConvert an Ed25519 public key to a Curve25519 public key',
'sodium_crypto_sign_ed25519_sk_to_curve25519': '(string $secret_key): string\nConvert an Ed25519 secret key to a Curve25519 secret key',
'sodium_crypto_sign_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nJoin a secret key and public key together',
'sodium_crypto_sign_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
'sodium_crypto_sign_open': '(string $signed_message, string $public_key): string|false\nCheck that the signed message has a valid signature',
'sodium_crypto_sign_publickey_from_secretkey': '(string $secret_key): string\nExtract the Ed25519 public key from the secret key',
'sodium_crypto_sign_publickey': '(string $key_pair): string\nExtract the Ed25519 public key from a keypair',
'sodium_crypto_sign_secretkey': '(string $key_pair): string\nExtract the Ed25519 secret key from a keypair',
'sodium_crypto_sign_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
'sodium_crypto_sign_verify_detached': '(string $signature, string $message, string $public_key): bool\nVerify signature for the message',
'sodium_crypto_sign': '(string $message, string $secret_key): string\nSign a message',
'sodium_crypto_stream_keygen': '(): string\nGenerate a random sodium_crypto_stream key.',
'sodium_crypto_stream_xchacha20_keygen': '(): string\nReturns a secure random key',
'sodium_crypto_stream_xchacha20_xor_ic': '(string $message, string $nonce, int $counter, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
'sodium_crypto_stream_xchacha20_xor': '(string $message, string $nonce, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
'sodium_crypto_stream_xchacha20': '(int $length, string $nonce, string $key): string\nExpands the key and nonce into a keystream of pseudorandom bytes',
'sodium_crypto_stream_xor': '(string $message, string $nonce, string $key): string\nEncrypt a message without authentication',
'sodium_crypto_stream': '(int $length, string $nonce, string $key): string\nGenerate a deterministic sequence of bytes from a seed',
'sodium_hex2bin': '(string $string, string $ignore = ""): string\nDecodes a hexadecimally encoded binary string',
'sodium_increment': '(string $string): void\nIncrement large number',
'sodium_memcmp': '(string $string1, string $string2): int\nTest for equality in constant-time',
'sodium_memzero': '(string $string): void\nOverwrite a string with NUL characters',
'sodium_pad': '(string $string, int $block_size): string\nAdd padding data',
'sodium_unpad': '(string $string, int $block_size): string\nRemove padding data',
'ob_tidyhandler': '(string $input, int $mode = ?): string\nob_start callback function to repair the buffer',
'tidy_access_count': '(tidy $tidy): int\nReturns the Number of Tidy accessibility warnings encountered for specified document',
'tidy_config_count': '(tidy $tidy): int\nReturns the Number of Tidy configuration errors encountered for specified document',
'tidy_error_count': '(tidy $tidy): int\nReturns the Number of Tidy errors encountered for specified document',
'tidy_get_output': '(tidy $tidy): string\nReturn a string representing the parsed tidy markup',
'tidy_warning_count': '(tidy $tidy): int\nReturns the Number of Tidy warnings encountered for specified document',
'tidy::body': '(): tidyNode|null\nReturns a tidyNode object starting from the ltbodygt tag of the tidy parse tree',
'tidy_get_body': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the ltbodygt tag of the tidy parse tree',
'tidy::cleanRepair': '(): bool\nExecute configured cleanup and repair operations on parsed markup',
'tidy_clean_repair': '(tidy $tidy): bool\nExecute configured cleanup and repair operations on parsed markup',
'tidy::diagnose': '(): bool\nRun configured diagnostics on parsed and repaired markup',
'tidy_diagnose': '(tidy $tidy): bool\nRun configured diagnostics on parsed and repaired markup',
'tidy_get_error_buffer': '(tidy $tidy): string|false\nReturn warnings and errors which occurred parsing the specified document',
'tidy::getConfig': '(): array\nGet current Tidy configuration',
'tidy_get_config': '(tidy $tidy): array\nGet current Tidy configuration',
'tidy::getHtmlVer': '(): int\nGet the Detected HTML version for the specified document',
'tidy_get_html_ver': '(tidy $tidy): int\nGet the Detected HTML version for the specified document',
'tidy::getOpt': '(string $option): string|int|bool\nReturns the value of the specified configuration option for the tidy document',
'tidy_getopt': '(tidy $tidy, string $option): string|int|bool\nReturns the value of the specified configuration option for the tidy document',
'tidy::getOptDoc': '(string $option): string|false\nReturns the documentation for the given option name',
'tidy_get_opt_doc': '(tidy $tidy, string $option): string|false\nReturns the documentation for the given option name',
'tidy::getRelease': '(): string\nGet release date (version) for Tidy library',
'tidy_get_release': '(): string\nGet release date (version) for Tidy library',
'tidy::getStatus': '(): int\nGet status of specified document',
'tidy_get_status': '(tidy $tidy): int\nGet status of specified document',
'tidy::head': '(): tidyNode|null\nReturns a tidyNode object starting from the ltheadgt tag of the tidy parse tree',
'tidy_get_head': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the ltheadgt tag of the tidy parse tree',
'tidy::html': '(): tidyNode|null\nReturns a tidyNode object starting from the lthtmlgt tag of the tidy parse tree',
'tidy_get_html': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the lthtmlgt tag of the tidy parse tree',
'tidy::isXhtml': '(): bool\nIndicates if the document is a XHTML document',
'tidy_is_xhtml': '(tidy $tidy): bool\nIndicates if the document is a XHTML document',
'tidy::isXml': '(): bool\nIndicates if the document is a generic (non HTML/XHTML) XML document',
'tidy_is_xml': '(tidy $tidy): bool\nIndicates if the document is a generic (non HTML/XHTML) XML document',
'tidy::parseFile': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): bool\nParse markup in file or URI',
'tidy_parse_file': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): tidy|false\nParse markup in file or URI',
'tidy::parseString': '(string $string, array|string|null $config = null, string|null $encoding = null): bool\nParse a document stored in a string',
'tidy_parse_string': '(string $string, array|string|null $config = null, string|null $encoding = null): tidy|false\nParse a document stored in a string',
'tidy::repairFile': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
'tidy_repair_file': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
'tidy::repairString': '(string $string, array|string|null $config = null, string|null $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
'tidy_repair_string': '(string $string, array|string|null $config = null, string|null $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
'tidy::root': '(): tidyNode|null\nReturns a tidyNode object representing the root of the tidy parse tree',
'tidy_get_root': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object representing the root of the tidy parse tree',
'tidyNode::getNextSibling': '(): tidyNode|null\nReturns the next sibling node of the current node',
'tidyNode::getParent': '(): tidyNode|null\nReturns the parent node of the current node',
'tidyNode::getPreviousSibling': '(): tidyNode|null\nReturns the previous sibling node of the current node',
'tidyNode::hasChildren': '(): bool\nChecks if a node has children',
'tidyNode::hasSiblings': '(): bool\nChecks if a node has siblings',
'tidyNode::isAsp': '(): bool\nChecks if this node is ASP',
'tidyNode::isComment': '(): bool\nChecks if a node represents a comment',
'tidyNode::isHtml': '(): bool\nChecks if a node is an element node',
'tidyNode::isJste': '(): bool\nChecks if this node is JSTE',
'tidyNode::isPhp': '(): bool\nChecks if a node is PHP',
'tidyNode::isText': '(): bool\nChecks if a node represents text (no markup)',
'odbc_autocommit': '(Odbc\\Connection $odbc, bool|null $enable = null): int|bool\nToggle autocommit behaviour',
'odbc_binmode': '(Odbc\\Result $statement, int $mode): true\nHandling of binary column data',
'odbc_close_all': '(): void\nClose all ODBC connections',
'odbc_close': '(Odbc\\Connection $odbc): void\nClose an ODBC connection',
'odbc_columnprivileges': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table, string $column): Odbc\\Result|false\nLists columns and associated privileges for the given table',
'odbc_columns': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $table = null, string|null $column = null): Odbc\\Result|false\nLists the column names in specified tables',
'odbc_commit': '(Odbc\\Connection $odbc): bool\nCommit an ODBC transaction',
'odbc_connect': '(string $dsn, string|null $user = null, string|null $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nConnect to a datasource',
'odbc_connection_string_is_quoted': '(string $str): bool\nDetermines if an ODBC connection string value is quoted',
'odbc_connection_string_quote': '(string $str): string\nQuotes an ODBC connection string value',
'odbc_connection_string_should_quote': '(string $str): bool\nDetermines if an ODBC connection string value should be quoted',
'odbc_cursor': '(Odbc\\Result $statement): string|false\nGet cursorname',
'odbc_data_source': '(Odbc\\Connection $odbc, int $fetch_type): array|null|false\nReturns information about available DSNs',
'odbc_do': 'Alias of odbc_exec',
'odbc_error': '(Odbc\\Connection|null $odbc = null): string\nGet the last error code',
'odbc_errormsg': '(Odbc\\Connection|null $odbc = null): string\nGet the last error message',
'odbc_exec': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nDirectly execute an SQL statement',
'odbc_execute': '(Odbc\\Result $statement, array $params = []): bool\nExecute a prepared statement',
'odbc_fetch_array': '(Odbc\\Result $statement, int|null $row = null): array|false\nFetch a result row as an associative array',
'odbc_fetch_into': '(Odbc\\Result $statement, array $array, int|null $row = null): int|false\nFetch one result row into array',
'odbc_fetch_object': '(Odbc\\Result $statement, int|null $row = null): stdClass|false\nFetch a result row as an object',
'odbc_fetch_row': '(Odbc\\Result $statement, int|null $row = null): bool\nFetch a row',
'odbc_field_len': '(Odbc\\Result $statement, int $field): int|false\nGet the length (precision) of a field',
'odbc_field_name': '(Odbc\\Result $statement, int $field): string|false\nGet the columnname',
'odbc_field_num': '(Odbc\\Result $statement, string $field): int|false\nReturn column number',
'odbc_field_precision': 'Alias of odbc_field_len',
'odbc_field_scale': '(Odbc\\Result $statement, int $field): int|false\nGet the scale of a field',
'odbc_field_type': '(Odbc\\Result $statement, int $field): string|false\nDatatype of a field',
'odbc_foreignkeys': '(Odbc\\Connection $odbc, string|null $pk_catalog, string $pk_schema, string $pk_table, string $fk_catalog, string $fk_schema, string $fk_table): Odbc\\Result|false\nRetrieves a list of foreign keys',
'odbc_free_result': '(Odbc\\Result $statement): true\nFree objects associated with a result',
'odbc_gettypeinfo': '(Odbc\\Connection $odbc, int $data_type = ?): Odbc\\Result|false\nRetrieves information about data types supported by the data source',
'odbc_longreadlen': '(Odbc\\Result $statement, int $length): true\nHandling of LONG columns',
'odbc_next_result': '(Odbc\\Result $statement): bool\nChecks if multiple results are available',
'odbc_num_fields': '(Odbc\\Result $statement): int\nNumber of columns in a result',
'odbc_num_rows': '(Odbc\\Result $statement): int\nNumber of rows in a result',
'odbc_pconnect': '(string $dsn, string|null $user = null, string|null $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nOpen a persistent database connection',
'odbc_prepare': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nPrepares a statement for execution',
'odbc_primarykeys': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table): Odbc\\Result|false\nGets the primary keys for a table',
'odbc_procedurecolumns': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $procedure = null, string|null $column = null): Odbc\\Result|false\nRetrieve information about parameters to procedures',
'odbc_procedures': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $procedure = null): Odbc\\Result|false\nGet the list of procedures stored in a specific data source',
'odbc_result_all': '(Odbc\\Result $statement, string $format = ""): int|false\nPrint result as HTML table',
'odbc_result': '(Odbc\\Result $statement, string|int $field): string|bool|null\nGet result data',
'odbc_rollback': '(Odbc\\Connection $odbc): bool\nRollback a transaction',
'odbc_setoption': '(Odbc\\Connection|Odbc\\Result $odbc, int $which, int $option, int $value): bool\nAdjust ODBC settings',
'odbc_specialcolumns': '(Odbc\\Connection $odbc, int $type, string|null $catalog, string $schema, string $table, int $scope, int $nullable): Odbc\\Result|false\nRetrieves special columns',
'odbc_statistics': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table, int $unique, int $accuracy): Odbc\\Result|false\nRetrieve statistics about a table',
'odbc_tableprivileges': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table): Odbc\\Result|false\nLists tables and the privileges associated with each table',
'odbc_tables': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $table = null, string|null $types = null): Odbc\\Result|false\nGet the list of table names stored in a specific data source',
'xml_error_string': '(int $error_code): string|null\nGet XML parser error string',
'xml_get_current_byte_index': '(XMLParser $parser): int\nGet current byte index for an XML parser',
'xml_get_current_column_number': '(XMLParser $parser): int\nGet current column number for an XML parser',
'xml_get_current_line_number': '(XMLParser $parser): int\nGet current line number for an XML parser',
'xml_get_error_code': '(XMLParser $parser): int\nGet XML parser error code',
'xml_parse_into_struct': '(XMLParser $parser, string $data, array $values, array $index = null): int|false\nParse XML data into an array structure',
'xml_parse': '(XMLParser $parser, string $data, bool $is_final = false): int\nStart parsing an XML document',
'xml_parser_create_ns': '(string|null $encoding = null, string $separator = ":"): XMLParser\nCreate an XML parser with namespace support',
'xml_parser_create': '(string|null $encoding = null): XMLParser\nCreate an XML parser',
'xml_parser_free': '(XMLParser $parser): bool\nFree an XML parser',
'xml_parser_get_option': '(XMLParser $parser, int $option): string|int|bool\nGet options from an XML parser',
'xml_parser_set_option': '(XMLParser $parser, int $option, string|int|bool $value): bool\nSet options in an XML parser',
'xml_set_character_data_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up character data handler',
'xml_set_default_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up default handler',
'xml_set_element_handler': '(XMLParser $parser, callable|string|null $start_handler, callable|string|null $end_handler): true\nSet up start and end element handlers',
'xml_set_end_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up end namespace declaration handler',
'xml_set_external_entity_ref_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up external entity reference handler',
'xml_set_notation_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up notation declaration handler',
'xml_set_object': '(XMLParser $parser, object $object): true\nUse XML Parser within an object',
'xml_set_processing_instruction_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up processing instruction (PI) handler',
'xml_set_start_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up start namespace declaration handler',
'xml_set_unparsed_entity_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up unparsed entity declaration handler',
'XMLReader::close': '(): true\nClose the XMLReader input',
'XMLReader::expand': '(DOMNode|null $baseNode = null): DOMNode|false\nReturns a copy of the current node as a DOM object',
'XMLReader::fromStream': '(resource $stream, string|null $encoding = null, int $flags = ?, string|null $documentUri = null): static\nCreates an XMLReader from a stream to read from',
'XMLReader::fromString': '(string $source, string|null $encoding = null, int $flags = ?): static\nCreates an XMLReader from an XML string',
'XMLReader::fromUri': '(string $uri, string|null $encoding = null, int $flags = ?): static\nCreates an XMLReader from a URI to read from',
'XMLReader::getAttribute': '(string $name): string|null\nGet the value of a named attribute',
'XMLReader::getAttributeNo': '(int $index): string|null\nGet the value of an attribute by index',
'XMLReader::getAttributeNs': '(string $name, string $namespace): string|null\nGet the value of an attribute by localname and URI',
'XMLReader::getParserProperty': '(int $property): bool\nIndicates if specified property has been set',
'XMLReader::isValid': '(): bool\nIndicates if the parsed document is valid',
'XMLReader::lookupNamespace': '(string $prefix): string|null\nLookup namespace for a prefix',
'XMLReader::moveToAttribute': '(string $name): bool\nMove cursor to a named attribute',
'XMLReader::moveToAttributeNo': '(int $index): bool\nMove cursor to an attribute by index',
'XMLReader::moveToAttributeNs': '(string $name, string $namespace): bool\nMove cursor to a named attribute',
'XMLReader::moveToElement': '(): bool\nPosition cursor on the parent Element of current Attribute',
'XMLReader::moveToFirstAttribute': '(): bool\nPosition cursor on the first Attribute',
'XMLReader::moveToNextAttribute': '(): bool\nPosition cursor on the next Attribute',
'XMLReader::next': '(string|null $name = null): bool\nMove cursor to next node skipping all subtrees',
'XMLReader::open': '(string $uri, string|null $encoding = null, int $flags = ?): XMLReader\nSet the URI containing the XML to parse',
'XMLReader::open': '(string $uri, string|null $encoding = null, int $flags = ?): bool\nSet the URI containing the XML to parse',
'XMLReader::read': '(): bool\nMove to next node in document',
'XMLReader::readInnerXml': '(): string\nRetrieve XML from current node',
'XMLReader::readOuterXml': '(): string\nRetrieve XML from current node, including itself',
'XMLReader::readString': '(): string\nReads the contents of the current node as a string',
'XMLReader::setParserProperty': '(int $property, bool $value): bool\nSet parser options',
'XMLReader::setRelaxNGSchema': '(string|null $filename): bool\nSet the filename or URI for a RelaxNG Schema',
'XMLReader::setRelaxNGSchemaSource': '(string|null $source): bool\nSet the data containing a RelaxNG Schema',
'XMLReader::setSchema': '(string|null $filename): bool\nValidate document against XSD',
'XMLReader::XML': '(string $source, string|null $encoding = null, int $flags = ?): XMLReader\nSet the data containing the XML to parse',
'XMLReader::XML': '(string $source, string|null $encoding = null, int $flags = ?): bool\nSet the data containing the XML to parse',
'XMLWriter::endAttribute': '(): bool\nEnd attribute',
'xmlwriter_end_attribute': '(XMLWriter $writer): bool\nEnd attribute',
'XMLWriter::endCdata': '(): bool\nEnd current CDATA',
'xmlwriter_end_cdata': '(XMLWriter $writer): bool\nEnd current CDATA',
'XMLWriter::endComment': '(): bool\nCreate end comment',
'xmlwriter_end_comment': '(XMLWriter $writer): bool\nCreate end comment',
'XMLWriter::endDocument': '(): bool\nEnd current document',
'xmlwriter_end_document': '(XMLWriter $writer): bool\nEnd current document',
'XMLWriter::endDtd': '(): bool\nEnd current DTD',
'xmlwriter_end_dtd': '(XMLWriter $writer): bool\nEnd current DTD',
'XMLWriter::endDtdAttlist': '(): bool\nEnd current DTD AttList',
'xmlwriter_end_dtd_attlist': '(XMLWriter $writer): bool\nEnd current DTD AttList',
'XMLWriter::endDtdElement': '(): bool\nEnd current DTD element',
'xmlwriter_end_dtd_element': '(XMLWriter $writer): bool\nEnd current DTD element',
'XMLWriter::endDtdEntity': '(): bool\nEnd current DTD Entity',
'xmlwriter_end_dtd_entity': '(XMLWriter $writer): bool\nEnd current DTD Entity',
'XMLWriter::endElement': '(): bool\nEnd current element',
'xmlwriter_end_element': '(XMLWriter $writer): bool\nEnd current element',
'XMLWriter::endPi': '(): bool\nEnd current PI',
'xmlwriter_end_pi': '(XMLWriter $writer): bool\nEnd current PI',
'XMLWriter::flush': '(bool $empty = true): string|int\nFlush current buffer',
'xmlwriter_flush': '(XMLWriter $writer, bool $empty = true): string|int\nFlush current buffer',
'XMLWriter::fullEndElement': '(): bool\nEnd current element',
'xmlwriter_full_end_element': '(XMLWriter $writer): bool\nEnd current element',
'XMLWriter::openMemory': '(): bool\nCreate new xmlwriter using memory for string output',
'xmlwriter_open_memory': '(): XMLWriter|false\nCreate new xmlwriter using memory for string output',
'XMLWriter::openUri': '(string $uri): bool\nCreate new xmlwriter using source uri for output',
'xmlwriter_open_uri': '(string $uri): XMLWriter|false\nCreate new xmlwriter using source uri for output',
'XMLWriter::outputMemory': '(bool $flush = true): string\nReturns current buffer',
'xmlwriter_output_memory': '(XMLWriter $writer, bool $flush = true): string\nReturns current buffer',
'XMLWriter::setIndent': '(bool $enable): bool\nToggle indentation on/off',
'xmlwriter_set_indent': '(XMLWriter $writer, bool $enable): bool\nToggle indentation on/off',
'XMLWriter::setIndentString': '(string $indentation): bool\nSet string used for indenting',
'xmlwriter_set_indent_string': '(XMLWriter $writer, string $indentation): bool\nSet string used for indenting',
'XMLWriter::startAttribute': '(string $name): bool\nCreate start attribute',
'xmlwriter_start_attribute': '(XMLWriter $writer, string $name): bool\nCreate start attribute',
'XMLWriter::startAttributeNs': '(string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced attribute',
'xmlwriter_start_attribute_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced attribute',
'XMLWriter::startCdata': '(): bool\nCreate start CDATA tag',
'xmlwriter_start_cdata': '(XMLWriter $writer): bool\nCreate start CDATA tag',
'XMLWriter::startComment': '(): bool\nCreate start comment',
'xmlwriter_start_comment': '(XMLWriter $writer): bool\nCreate start comment',
'XMLWriter::startDocument': '(string|null $version = "1.0", string|null $encoding = null, string|null $standalone = null): bool\nCreate document tag',
'xmlwriter_start_document': '(XMLWriter $writer, string|null $version = "1.0", string|null $encoding = null, string|null $standalone = null): bool\nCreate document tag',
'XMLWriter::startDtd': '(string $qualifiedName, string|null $publicId = null, string|null $systemId = null): bool\nCreate start DTD tag',
'xmlwriter_start_dtd': '(XMLWriter $writer, string $qualifiedName, string|null $publicId = null, string|null $systemId = null): bool\nCreate start DTD tag',
'XMLWriter::startDtdAttlist': '(string $name): bool\nCreate start DTD AttList',
'xmlwriter_start_dtd_attlist': '(XMLWriter $writer, string $name): bool\nCreate start DTD AttList',
'XMLWriter::startDtdElement': '(string $qualifiedName): bool\nCreate start DTD element',
'xmlwriter_start_dtd_element': '(XMLWriter $writer, string $qualifiedName): bool\nCreate start DTD element',
'XMLWriter::startDtdEntity': '(string $name, bool $isParam): bool\nCreate start DTD Entity',
'xmlwriter_start_dtd_entity': '(XMLWriter $writer, string $name, bool $isParam): bool\nCreate start DTD Entity',
'XMLWriter::startElement': '(string $name): bool\nCreate start element tag',
'xmlwriter_start_element': '(XMLWriter $writer, string $name): bool\nCreate start element tag',
'XMLWriter::startElementNs': '(string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced element tag',
'xmlwriter_start_element_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced element tag',
'XMLWriter::startPi': '(string $target): bool\nCreate start PI tag',
'xmlwriter_start_pi': '(XMLWriter $writer, string $target): bool\nCreate start PI tag',
'XMLWriter::text': '(string $content): bool\nWrite text',
'xmlwriter_text': '(XMLWriter $writer, string $content): bool\nWrite text',
'XMLWriter::toMemory': '(): static\nCreate new XMLWriter using memory for string output',
'XMLWriter::toStream': '(resource $stream): static\nCreate new XMLWriter using a stream for output',
'XMLWriter::toUri': '(string $uri): static\nCreate new XMLWriter using a URI for output',
'XMLWriter::writeAttribute': '(string $name, string $value): bool\nWrite full attribute',
'xmlwriter_write_attribute': '(XMLWriter $writer, string $name, string $value): bool\nWrite full attribute',
'XMLWriter::writeAttributeNs': '(string|null $prefix, string $name, string|null $namespace, string $value): bool\nWrite full namespaced attribute',
'xmlwriter_write_attribute_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace, string $value): bool\nWrite full namespaced attribute',
'XMLWriter::writeCdata': '(string $content): bool\nWrite full CDATA tag',
'xmlwriter_write_cdata': '(XMLWriter $writer, string $content): bool\nWrite full CDATA tag',
'XMLWriter::writeComment': '(string $content): bool\nWrite full comment tag',
'xmlwriter_write_comment': '(XMLWriter $writer, string $content): bool\nWrite full comment tag',
'XMLWriter::writeDtd': '(string $name, string|null $publicId = null, string|null $systemId = null, string|null $content = null): bool\nWrite full DTD tag',
'xmlwriter_write_dtd': '(XMLWriter $writer, string $name, string|null $publicId = null, string|null $systemId = null, string|null $content = null): bool\nWrite full DTD tag',
'XMLWriter::writeDtdAttlist': '(string $name, string $content): bool\nWrite full DTD AttList tag',
'xmlwriter_write_dtd_attlist': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD AttList tag',
'XMLWriter::writeDtdElement': '(string $name, string $content): bool\nWrite full DTD element tag',
'xmlwriter_write_dtd_element': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD element tag',
'XMLWriter::writeDtdEntity': '(string $name, string $content, bool $isParam = false, string|null $publicId = null, string|null $systemId = null, string|null $notationData = null): bool\nWrite full DTD Entity tag',
'xmlwriter_write_dtd_entity': '(XMLWriter $writer, string $name, string $content, bool $isParam = false, string|null $publicId = null, string|null $systemId = null, string|null $notationData = null): bool\nWrite full DTD Entity tag',
'XMLWriter::writeElement': '(string $name, string|null $content = null): bool\nWrite full element tag',
'xmlwriter_write_element': '(XMLWriter $writer, string $name, string|null $content = null): bool\nWrite full element tag',
'XMLWriter::writeElementNs': '(string|null $prefix, string $name, string|null $namespace, string|null $content = null): bool\nWrite full namespaced element tag',
'xmlwriter_write_element_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace, string|null $content = null): bool\nWrite full namespaced element tag',
'XMLWriter::writePi': '(string $target, string $content): bool\nWrites a PI',
'xmlwriter_write_pi': '(XMLWriter $writer, string $target, string $content): bool\nWrites a PI',
'XMLWriter::writeRaw': '(string $content): bool\nWrite a raw XML text',
'xmlwriter_write_raw': '(XMLWriter $writer, string $content): bool\nWrite a raw XML text',
'XSLTProcessor::getParameter': '(string $namespace, string $name): string|false\nGet value of a parameter',
'XSLTProcessor::getSecurityPrefs': '(): int\nGet security preferences',
'XSLTProcessor::hasExsltSupport': '(): bool\nDetermine if PHP has EXSLT support',
'XSLTProcessor::importStylesheet': '(object $stylesheet): bool\nImport stylesheet',
'XSLTProcessor::registerPHPFunctionNS': '(string $namespaceURI, string $name, callable $callable): void\nRegister a PHP function as namespaced XSLT function',
'XSLTProcessor::registerPHPFunctions': '(array|string|null $functions = null): void\nEnables the ability to use PHP functions as XSLT functions',
'XSLTProcessor::removeParameter': '(string $namespace, string $name): bool\nRemove parameter',
'XSLTProcessor::setParameter': '(string $namespace, string $name, string $value): bool\nSet value for a parameter',
'XSLTProcessor::setParameter': '(string $namespace, array $options): bool\nSet value for a parameter',
'XSLTProcessor::setProfiling': '(string|null $filename): true\nSets profiling output file',
'XSLTProcessor::setSecurityPrefs': '(int $preferences): int\nSet security preferences',
'XSLTProcessor::transformToDoc': '(object $document, string|null $returnClass = null): object|false\nTransform to a document',
'XSLTProcessor::transformToUri': '(object $document, string $uri): int\nTransform to URI',
'XSLTProcessor::transformToXml': '(object $document): string|null|false\nTransform to XML',
'zip_close': '(resource $zip): void\nClose a ZIP file archive',
'zip_entry_close': '(resource $zip_entry): bool\nClose a directory entry',
'zip_entry_compressedsize': '(resource $zip_entry): int|false\nRetrieve the compressed size of a directory entry',
'zip_entry_compressionmethod': '(resource $zip_entry): string|false\nRetrieve the compression method of a directory entry',
'zip_entry_filesize': '(resource $zip_entry): int|false\nRetrieve the actual file size of a directory entry',
'zip_entry_name': '(resource $zip_entry): string|false\nRetrieve the name of a directory entry',
'zip_entry_open': '(resource $zip_dp, resource $zip_entry, string $mode = "rb"): bool\nOpen a directory entry for reading',
'zip_entry_read': '(resource $zip_entry, int $len = 1024): string|false\nRead from an open directory entry',
'zip_open': '(string $filename): resource|int|false\nOpen a ZIP file archive',
'zip_read': '(resource $zip): resource|false\nRead next entry in a ZIP file archive',
'ZipArchive::addEmptyDir': '(string $dirname, int $flags = ?): bool\nAdd a new directory',
'ZipArchive::addFile': '(string $filepath, string $entryname = "", int $start = ?, int $length = ZipArchive::LENGTH_TO_END, int $flags = ZipArchive::FL_OVERWRITE): bool\nAdds a file to a ZIP archive from the given path',
'ZipArchive::addFromString': '(string $name, string $content, int $flags = ZipArchive::FL_OVERWRITE): bool\nAdd a file to a ZIP archive using its contents',
'ZipArchive::addGlob': '(string $pattern, int $flags = ?, array $options = []): array|false\nAdd files from a directory by glob pattern',
'ZipArchive::addPattern': '(string $pattern, string $path = ".", array $options = []): array|false\nAdd files from a directory by PCRE pattern',
'ZipArchive::clearError': '(): void\nClear the status error message, system and/or zip messages',
'ZipArchive::close': '(): bool\nClose the active archive (opened or newly created)',
'ZipArchive::count': '(): int\nCounts the number of files in the archive',
'ZipArchive::deleteIndex': '(int $index): bool\nDelete an entry in the archive using its index',
'ZipArchive::deleteName': '(string $name): bool\nDelete an entry in the archive using its name',
'ZipArchive::extractTo': '(string $pathto, array|string|null $files = null): bool\nExtract the archive contents',
'ZipArchive::getArchiveComment': '(int $flags = ?): string|false\nReturns the Zip archive comment',
'ZipArchive::getArchiveFlag': '(int $flag, int $flags = ?): int\nReturns the value of a Zip archive global flag',
'ZipArchive::getCommentIndex': '(int $index, int $flags = ?): string|false\nReturns the comment of an entry using the entry index',
'ZipArchive::getCommentName': '(string $name, int $flags = ?): string|false\nReturns the comment of an entry using the entry name',
'ZipArchive::getExternalAttributesIndex': '(int $index, int $opsys, int $attr, int $flags = ?): bool\nRetrieve the external attributes of an entry defined by its index',
'ZipArchive::getExternalAttributesName': '(string $name, int $opsys, int $attr, int $flags = ?): bool\nRetrieve the external attributes of an entry defined by its name',
'ZipArchive::getFromIndex': '(int $index, int $len = ?, int $flags = ?): string|false\nReturns the entry contents using its index',
'ZipArchive::getFromName': '(string $name, int $len = ?, int $flags = ?): string|false\nReturns the entry contents using its name',
'ZipArchive::getNameIndex': '(int $index, int $flags = ?): string|false\nReturns the name of an entry using its index',
'ZipArchive::getStatusString': '(): string\nReturns the status error message, system and/or zip messages',
'ZipArchive::getStream': '(string $name): resource|false\nGet a file handler to the entry defined by its name (read only)',
'ZipArchive::getStreamIndex': '(int $index, int $flags = ?): resource|false\nGet a file handler to the entry defined by its index (read only)',
'ZipArchive::getStreamName': '(string $name, int $flags = ?): resource|false\nGet a file handler to the entry defined by its name (read only)',
'ZipArchive::isCompressionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a compression method is supported by libzip',
'ZipArchive::isEncryptionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a encryption method is supported by libzip',
'ZipArchive::locateName': '(string $name, int $flags = ?): int|false\nReturns the index of the entry in the archive',
'ZipArchive::open': '(string $filename, int $flags = ?): bool|int\nOpen a ZIP file archive',
'ZipArchive::registerCancelCallback': '(callable $callback): bool\nRegister a callback to allow cancellation during archive close.',
'ZipArchive::registerProgressCallback': '(float $rate, callable $callback): bool\nRegister a callback to provide updates during archive close.',
'ZipArchive::renameIndex': '(int $index, string $new_name): bool\nRenames an entry defined by its index',
'ZipArchive::renameName': '(string $name, string $new_name): bool\nRenames an entry defined by its name',
'ZipArchive::replaceFile': '(string $filepath, int $index, int $start = ?, int $length = ZipArchive::LENGTH_TO_END, int $flags = ?): bool\nReplace file in ZIP archive with a given path',
'ZipArchive::setArchiveComment': '(string $comment): bool\nSet the comment of a ZIP archive',
'ZipArchive::setArchiveFlag': '(int $flag, int $value): bool\nSet a global flag of a ZIP archive',
'ZipArchive::setCommentIndex': '(int $index, string $comment): bool\nSet the comment of an entry defined by its index',
'ZipArchive::setCommentName': '(string $name, string $comment): bool\nSet the comment of an entry defined by its name',
'ZipArchive::setCompressionIndex': '(int $index, int $method, int $compflags = ?): bool\nSet the compression method of an entry defined by its index',
'ZipArchive::setCompressionName': '(string $name, int $method, int $compflags = ?): bool\nSet the compression method of an entry defined by its name',
'ZipArchive::setEncryptionIndex': '(int $index, int $method, string|null $password = null): bool\nSet the encryption method of an entry defined by its index',
'ZipArchive::setEncryptionName': '(string $name, int $method, string|null $password = null): bool\nSet the encryption method of an entry defined by its name',
'ZipArchive::setExternalAttributesIndex': '(int $index, int $opsys, int $attr, int $flags = ?): bool\nSet the external attributes of an entry defined by its index',
'ZipArchive::setExternalAttributesName': '(string $name, int $opsys, int $attr, int $flags = ?): bool\nSet the external attributes of an entry defined by its name',
'ZipArchive::setMtimeIndex': '(int $index, int $timestamp, int $flags = ?): bool\nSet the modification time of an entry defined by its index',
'ZipArchive::setMtimeName': '(string $name, int $timestamp, int $flags = ?): bool\nSet the modification time of an entry defined by its name',
'ZipArchive::setPassword': '(string $password): bool\nSet the password for the active archive',
'ZipArchive::statIndex': '(int $index, int $flags = ?): array|false\nGet the details of an entry defined by its index',
'ZipArchive::statName': '(string $name, int $flags = ?): array|false\nGet the details of an entry defined by its name',
'ZipArchive::unchangeAll': '(): bool\nUndo all changes done in the archive',
'ZipArchive::unchangeArchive': '(): bool\nRevert all global changes done in the archive',
'ZipArchive::unchangeIndex': '(int $index): bool\nRevert all changes done to an entry at the given index',
'ZipArchive::unchangeName': '(string $name): bool\nRevert all changes done to an entry with the given name',
});
jush.api.php_fun = jush.api.lowercase_keys({
'__construct': '(mixed ...$values)\nObject constructor',
'__destruct': '()\nObject destructor',
'__call': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in an object context',
'__callStatic': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in a static context',
'__get': '(string $name): mixed\nUtilized for reading data from inaccessible properties',
'__set': '(string $name, mixed $value): void\nRun when writing data to inaccessible properties',
'__isset': '(string $name): bool\nTriggered by calling isset() or empty() on inaccessible properties',
'__unset': '(string $name): void\nInvoked when unset() is used on inaccessible properties',
'__sleep': '(): array\nCalled by serialize()',
'__wakeup': '(): void\nCalled by unserialize()',
'__serialize': '(): array\nCalled by serialize()',
'__unserialize': '(array $data): void\nCalled by unserialize()',
'__toString': '(): string\nDecide how to react when object is converted to a string',
'__invoke': '(mixed ...$values): mixed\nCalled when a script tries to call an object as a function',
'__set_state': '(array $properties): object\nCalled by var_export() result',
'__clone': '(): void\nCalled after cloning',
'__debugInfo': '(): array\nCalled by var_dump()',
});
jush.api.php_new = jush.api.lowercase_keys({
'AllowDynamicProperties': 'Construct a new AllowDynamicProperties attribute instance',
'Attribute': '(int $flags = Attribute::TARGET_ALL)\nConstruct a new Attribute instance',
'Deprecated': '(string|null $message = null, string|null $since = null)\nConstruct a new Deprecated attribute instance',
'Override': 'Construct a new Override attribute instance',
'Closure': 'Constructor that disallows instantiation',
'Error': '(string $message = "", int $code = ?, Throwable|null $previous = null)\nConstruct the error object',
'ErrorException': '(string $message = "", int $code = ?, int $severity = E_ERROR, string|null $filename = null, int|null $line = null, Throwable|null $previous = null)\nConstructs the exception',
'Exception': '(string $message = "", int $code = ?, Throwable|null $previous = null)\nConstruct the exception',
'Fiber': '(callable $callback)\nCreates a new Fiber instance',
'FiberError': 'Constructor to disallow direct instantiation',
'InternalIterator': 'Private constructor to disallow direct instantiation',
'ReturnTypeWillChange': 'Construct a new ReturnTypeWillChange attribute instance',
'SensitiveParameter': 'Construct a new SensitiveParameter attribute instance',
'SensitiveParameterValue': '(mixed $value)\nConstructs a new SensitiveParameterValue object',
'WeakReference': 'Constructor that disallows instantiation',
'ArgumentCountError': 'ArgumentCountError is thrown when too few arguments are passed to a user-defined function or method',
'ArithmeticError': 'ArithmeticError is thrown when an error occurs while performing mathematical operations',
'ArrayAccess': 'Interface to provide accessing objects as arrays',
'AssertionError': 'AssertionError is thrown when an assertion made via assert fails',
'BackedEnum': 'The BackedEnum interface is automatically applied to backed enumerations by the engine',
'ClosedGeneratorException': 'A ClosedGeneratorException is thrown when trying to retrieve a value from a closed Generator',
'CompileError': 'CompileError is thrown for some compilation errors, which formerly issued a fatal error',
'Countable': 'Classes implementing Countable can be used with the count function',
'DivisionByZeroError': 'DivisionByZeroError is thrown when an attempt is made to divide a number by zero',
'Generator': 'Generator objects are returned from generators',
'Iterator': 'Interface for external iterators or objects that can be iterated themselves internally',
'IteratorAggregate': 'Interface to create an external Iterator',
'ParseError': 'ParseError is thrown when an error occurs while parsing PHP code, such as when eval is called',
'__PHP_Incomplete_Class': 'Created by unserialize when trying to unserialize an undefined class or a class that is not listed in the allowed_classes of unserialize\'s $options array',
'RequestParseBodyException': 'A RequestParseBodyException is thrown in request_parse_body when the request body is invalid, according to the Content-Type header',
'Serializable': 'Interface for customized serializing',
'stdClass': 'A generic empty class with dynamic properties',
'Stringable': 'The Stringable interface denotes a class as having a __toString() method',
'Throwable': 'Throwable is the base interface for any object that can be thrown via a throw statement, including Error and Exception',
'Traversable': 'Interface to detect if a class is traversable using foreach',
'TypeError': 'A TypeError may be thrown when: The value being set for a class property does not match the property\'s corresponding declared type',
'UnhandledMatchError': 'An UnhandledMatchError is thrown when the subject passed to a match expression is not handled by any arm of the match expression',
'UnitEnum': 'The UnitEnum interface is automatically applied to all enumerations by the engine',
'ValueError': 'A ValueError is thrown when the type of an argument is correct but the value of it is incorrect',
'WeakMap': 'A WeakMap is map (or dictionary) that accepts objects as keys',
'DateInterval': '(string $duration)\nCreates a new DateInterval object',
'DatePeriod': '(DateTimeInterface $start, DateInterval $interval, int $recurrences, int $options = ?)\nCreates a new DatePeriod object',
'DatePeriod': '(DateTimeInterface $start, DateInterval $interval, DateTimeInterface $end, int $options = ?)\nCreates a new DatePeriod object',
'DateTime': '(string $datetime = "now", DateTimeZone|null $timezone = null)\nReturns new DateTime object',
'DateError': 'Thrown when the timezone database is not found, or contains invalid data',
'DateException': 'Parent class of Date/Time exceptions, for issues that come to light due to user input, or free form text arguments that need to be parsed',
'DateInvalidOperationException': 'Thrown by DateTimeImmutable::sub and DateTime::sub when an unsupported operation is attempted',
'DateInvalidTimeZoneException': 'Thrown when an incorrect value is passed to DateTimeZone::__construct',
'DateMalformedIntervalStringException': 'Thrown when an invalid $duration argument is passed to DateInterval::__construct',
'DateMalformedPeriodStringException': 'Thrown when an invalid $isostr argument is passed to DatePeriod::__construct',
'DateMalformedStringException': 'Thrown when an invalid Date/Time string is detected',
'DateObjectError': 'Thrown when one of the Date/Time classes has not been correctly initialised',
'DateRangeError': 'Thrown by DateTime::getTimestamp, DateTimeImmutable::getTimestamp, and date_timestamp_get, on 32-bit platforms if the date object represents a date outside of the 32-bit signed range',
'DateTimeImmutable': 'Representation of date and time',
'DateTimeInterface': 'DateTimeInterface was created so that parameter, return, or property type declarations may accept either DateTimeImmutable or DateTime as a value',
'DateTimeZone': 'Representation of time zone',
'Directory': 'Instances of Directory are created by calling the dir function, not by the new operator',
'HashContext': 'Private constructor to disallow direct instantiation',
'JsonException': 'Exception thrown if JSON_THROW_ON_ERROR option is set for json_encode or json_decode',
'JsonSerializable': 'Objects implementing JsonSerializable can customize their JSON representation when encoded with json_encode',
'Random\\Engine\\Mt19937': '(int|null $seed = null, int $mode = MT_RAND_MT19937)\nConstructs a new Mt19937 engine',
'Random\\Engine\\PcgOneseq128XslRr64': '(string|int|null $seed = null)\nConstructs a new PCG Oneseq 128 XSL RR 64 engine',
'Random\\Engine\\Xoshiro256StarStar': '(string|int|null $seed = null)\nConstructs a new xoshiro256** engine',
'Random\\Randomizer': '(Random\\Engine|null $engine = null)\nConstructs a new Randomizer',
'Random\\BrokenRandomEngineError': 'Indicates that the used Random\\Engine is broken, e',
'Random\\CryptoSafeEngine': 'A marker interface indicating that the Random\\Engine returns cryptographically secure randomness',
'Random\\Engine\\Secure': 'Generates cryptographically secure randomness using the operating system’s CSPRNG',
'Random\\Engine': 'A Random\\Engine provides a low-level source of randomness by returning random bytes that are consumed by high-level APIs to perform their operations',
'Random\\RandomError': 'The base class for Errors that occur during generation or use of randomness',
'Random\\RandomException': 'The base class for Exceptions that occur during generation or use of randomness',
'ReflectionAttribute': 'Private constructor to disallow direct instantiation',
'ReflectionClass': '(object|string $objectOrClass)\nConstructs a ReflectionClass',
'ReflectionClassConstant': '(object|string $class, string $constant)\nConstructs a ReflectionClassConstant',
'ReflectionConstant': '(string $name)\nConstructs a ReflectionConstant',
'ReflectionEnum': '(object|string $objectOrClass)\nInstantiates a ReflectionEnum object',
'ReflectionEnumBackedCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumBackedCase object',
'ReflectionEnumUnitCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumUnitCase object',
'ReflectionExtension': '(string $name)\nConstructs a ReflectionExtension',
'ReflectionFiber': '(Fiber $fiber)\nConstructs a ReflectionFiber object',
'ReflectionFunction': '(Closure|string $function)\nConstructs a ReflectionFunction object',
'ReflectionGenerator': '(Generator $generator)\nConstructs a ReflectionGenerator object',
'ReflectionMethod': '(object|string $objectOrMethod, string $method)\nConstructs a ReflectionMethod',
'ReflectionMethod': '(string $classMethod)\nConstructs a ReflectionMethod',
'ReflectionObject': '(object $object)\nConstructs a ReflectionObject',
'ReflectionParameter': '(string|array|object $function, int|string $param)\nConstruct',
'ReflectionProperty': '(object|string $class, string $property)\nConstruct a ReflectionProperty object',
'ReflectionReference': 'Private constructor to disallow direct instantiation',
'ReflectionZendExtension': '(string $name)\nConstructs a ReflectionZendExtension object',
'Reflection': 'The reflection class',
'ReflectionException': 'The ReflectionException class',
'ReflectionFunctionAbstract': 'A parent class to ReflectionFunction, read its description for details',
'ReflectionType': 'The ReflectionType class reports information about a function\'s parameter/return type or a class\'s property type',
'Reflector': 'Reflector is an interface implemented by all exportable Reflection classes',
'AppendIterator': 'Constructs an AppendIterator',
'ArrayIterator': '(array|object $array = [], int $flags = ?)\nConstruct an ArrayIterator',
'ArrayObject': '(array|object $array = [], int $flags = ?, string $iteratorClass = ArrayIterator::class)\nConstruct a new array object',
'CachingIterator': '(Iterator $iterator, int $flags = CachingIterator::CALL_TOSTRING)\nConstruct a new CachingIterator object for the iterator',
'CallbackFilterIterator': '(Iterator $iterator, callable $callback)\nCreate a filtered iterator from another iterator',
'DirectoryIterator': '(string $directory)\nConstructs a new directory iterator from a path',
'FilesystemIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::SKIP_DOTS)\nConstructs a new filesystem iterator',
'FilterIterator': '(Iterator $iterator)\nConstruct a filterIterator',
'GlobIterator': '(string $pattern, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstruct a directory using glob',
'InfiniteIterator': '(Iterator $iterator)\nConstructs an InfiniteIterator',
'IteratorIterator': '(Traversable $iterator, string|null $class = null)\nCreate an iterator from anything that is traversable',
'LimitIterator': '(Iterator $iterator, int $offset = ?, int $limit = -1)\nConstruct a LimitIterator',
'MultipleIterator': '(int $flags = MultipleIterator::MIT_NEED_ALL | MultipleIterator::MIT_KEYS_NUMERIC)\nConstructs a new MultipleIterator',
'NoRewindIterator': '(Iterator $iterator)\nConstruct a NoRewindIterator',
'ParentIterator': '(RecursiveIterator $iterator)\nConstructs a ParentIterator',
'RecursiveCachingIterator': '(Iterator $iterator, int $flags = RecursiveCachingIterator::CALL_TOSTRING)\nConstruct',
'RecursiveCallbackFilterIterator': '(RecursiveIterator $iterator, callable $callback)\nCreate a RecursiveCallbackFilterIterator from a RecursiveIterator',
'RecursiveDirectoryIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstructs a RecursiveDirectoryIterator',
'RecursiveFilterIterator': '(RecursiveIterator $iterator)\nCreate a RecursiveFilterIterator from a RecursiveIterator',
'RecursiveIteratorIterator': '(Traversable $iterator, int $mode = RecursiveIteratorIterator::LEAVES_ONLY, int $flags = ?)\nConstruct a RecursiveIteratorIterator',
'RecursiveRegexIterator': '(RecursiveIterator $iterator, string $pattern, int $mode = RecursiveRegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreates a new RecursiveRegexIterator',
'RecursiveTreeIterator': '(RecursiveIterator|IteratorAggregate $iterator, int $flags = RecursiveTreeIterator::BYPASS_KEY, int $cachingIteratorFlags = CachingIterator::CATCH_GET_CHILD, int $mode = RecursiveTreeIterator::SELF_FIRST)\nConstruct a RecursiveTreeIterator',
'RegexIterator': '(Iterator $iterator, string $pattern, int $mode = RegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreate a new RegexIterator',
'SplFileInfo': '(string $filename)\nConstruct a new SplFileInfo object',
'SplFileObject': '(string $filename, string $mode = "r", bool $useIncludePath = false, resource|null $context = null)\nConstruct a new file object',
'SplFixedArray': '(int $size = ?)\nConstructs a new fixed array',
'SplTempFileObject': '(int $maxMemory = 2 * 1024 * 1024)\nConstruct a new temporary file object',
'BadFunctionCallException': 'Exception thrown if a callback refers to an undefined function or if some arguments are missing',
'BadMethodCallException': 'Exception thrown if a callback refers to an undefined method or if some arguments are missing',
'DomainException': 'Exception thrown if a value does not adhere to a defined valid data domain',
'EmptyIterator': 'The EmptyIterator class for an empty iterator',
'InvalidArgumentException': 'Exception thrown if an argument is not of the expected type',
'LengthException': 'Exception thrown if a length is invalid',
'LogicException': 'Exception that represents error in the program logic',
'OuterIterator': 'Classes implementing OuterIterator can be used to iterate over iterators',
'OutOfBoundsException': 'Exception thrown if a value is not a valid key',
'OutOfRangeException': 'Exception thrown when an illegal index was requested',
'OverflowException': 'Exception thrown when adding an element to a full container',
'RangeException': 'Exception thrown to indicate range errors during program execution',
'RecursiveArrayIterator': 'This iterator allows for unsetting and modifying values and keys while iterating over arrays and objects, in the same way as the ArrayIterator',
'RecursiveIterator': 'Classes implementing RecursiveIterator can be used to iterate over iterators recursively',
'RuntimeException': 'Exception thrown if an error which can only be found on runtime occurs',
'SeekableIterator': 'The Seekable iterator',
'SplDoublyLinkedList': 'The SplDoublyLinkedList class provides the main functionalities of a doubly linked list',
'SplHeap': 'The SplHeap class provides the main functionalities of a Heap',
'SplMaxHeap': 'The SplMaxHeap class provides the main functionalities of a heap, keeping the maximum on the top',
'SplMinHeap': 'The SplMinHeap class provides the main functionalities of a heap, keeping the minimum on the top',
'SplObjectStorage': 'The SplObjectStorage class provides a map from objects to data or, by ignoring data, an object set',
'SplObserver': 'The SplObserver interface is used alongside SplSubject to implement the Observer Design Pattern',
'SplPriorityQueue': 'The SplPriorityQueue class provides the main functionalities of a prioritized queue, implemented using a max heap',
'SplQueue': 'The SplQueue class provides the main functionalities of a queue implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_FIFO',
'SplStack': 'The SplStack class provides the main functionalities of a stack implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_LIFO',
'SplSubject': 'The SplSubject interface is used alongside SplObserver to implement the Observer Design Pattern',
'UnderflowException': 'Exception thrown when performing an invalid operation on an empty container, such as removing an element',
'UnexpectedValueException': 'Exception thrown if a value does not match with a set of values',
'streamWrapper': 'Constructs a new stream wrapper',
'php_user_filter': 'Children of this class are passed to stream_filter_register',
'StreamBucket': 'A stream bucket is a chunk of a stream which can be extracted from bucket brigades',
'BcMath\number': '(string|int $num)\nCreates a BcMath\number object',
'com': '(string $module_name, array|string|null $server_name = null, int $codepage = CP_ACP, string $typelib = "")\ncom class constructor',
'COMPersistHelper': '(variant|null $variant = null)\nConstruct a COMPersistHelper object',
'dotnet': '(string $assembly_name, string $datatype_name, int $codepage = CP_ACP)\ndotnet class constructor',
'variant': '(mixed $value = null, int $type = VT_EMPTY, int $codepage = CP_ACP)\nvariant class constructor',
'com_safearray_proxy': 'com_safearray_proxy is an internal class used for resolving multi-dimensional array accesses on SafeArray types',
'Dba\\Connection': 'A fully opaque class which replaces a dba resource as of PHP 8',
'FFI': '(FFI\\CType|string $type, bool $owned = true, bool $persistent = false): FFI\\CData|null\nCreates a C data structure',
'FFI\\CData': 'FFI\\CData objects can be used in a number of ways as a regular PHP data: C data of scalar types can be read and assigned via the $cdata property, e',
'FFI': 'Objects of this class are created by the factory methods FFI::cdef, FFI::load or FFI::scope',
'finfo': '(int $flags = FILEINFO_NONE, string|null $magic_database = null)\nAlias finfo_open',
'FTP\\Connection': 'A fully opaque class which replaces a ftp resource as of PHP 8',
'GdFont': 'A fully opaque class which replaces gd font resources as of PHP 8',
'GdImage': 'A fully opaque class which replaces gd resources as of PHP 8',
'Collator': '(string $locale)\nCreate a collator',
'IntlBreakIterator': 'Private constructor for disallowing instantiation',
'IntlCalendar': 'Private constructor for disallowing instantiation',
'IntlGregorianCalendar': '(IntlTimeZone $tz = ?, string $locale = ?)\nCreate the Gregorian Calendar class',
'IntlGregorianCalendar': '(int $timeZoneOrYear, int $localeOrMonth, int $dayOfMonth)\nCreate the Gregorian Calendar class',
'IntlGregorianCalendar': '(int $timeZoneOrYear, int $localeOrMonth, int $dayOfMonth, int $hour, int $minute, int $second = ?)\nCreate the Gregorian Calendar class',
'IntlRuleBasedBreakIterator': '(string $rules, bool $compiled = false)\nCreate iterator from ruleset',
'IntlTimeZone': 'Private constructor to disallow direct instantiation',
'Spoofchecker': 'Constructor',
'Transliterator': 'Private constructor to deny instantiation',
'UConverter': '(string|null $destination_encoding = null, string|null $source_encoding = null)\nCreate UConverter object',
'IntlDateFormatter': 'Date Formatter is a concrete class that enables locale-dependent formatting/parsing of dates using pattern strings and/or canned patterns',
'IntlChar': 'IntlChar provides access to a number of utility methods that can be used to access information about Unicode characters',
'IntlCodePointBreakIterator': 'This break iterator identifies the boundaries between UTF-8 code points',
'IntlDatePatternGenerator': 'Generates localized date and/or time format pattern strings suitable for use in IntlDateFormatter',
'IntlException': 'This class is used for generating exceptions when errors occur inside intl functions',
'IntlIterator': 'This class represents iterator objects throughout the intl extension whenever the iterator cannot be identified with any other object provided by the extension',
'IntlPartsIterator': 'Objects of this class can be obtained from IntlBreakIterator objects',
'Locale': 'Examples of identifiers include: en-US (English, United States) zh-Hant-TW (Chinese, Traditional Script, Taiwan) fr-CA, fr-FR (French for Canada and France respectively)',
'MessageFormatter': 'MessageFormatter is a concrete class that enables users to produce concatenated, language-neutral messages',
'Normalizer': 'The Unicode Consortium has defined a number of normalization forms reflecting the various needs of applications: Normalization Form D (NFD) - Canonical Decomposition Normalization Form C (NFC) - Canonical Decomposition followed by Canonical Composition Normalization Form KD (NFKD) - Compatibility Decomposition Normalization Form KC (NFKC) - Compatibility Decomposition followed by Canonical Composition The different forms are defined in terms of a set of transformations on the text, transformations that are expressed by both an algorithm and a set of data files',
'NumberFormatter': 'For currencies you can use currency format type to create a formatter that returns a string with the formatted number and the appropriate currency sign',
'ResourceBundle': 'Localized software products often require sets of data that are to be customized depending on current locale, e',
'PDO': '(string $dsn, string|null $username = null, string|null $password = null, array|null $options = null)\nCreates a PDO instance representing a connection to a database',
'PDOException': 'Represents an error raised by PDO',
'PDORow': 'Represents a row from a result set returned by PDOStatement::fetch called with PDO_FETCH_LAZY fetch mode',
'PDOStatement': 'Represents a prepared statement and, after the statement is executed, an associated result set',
'Phar': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, string|null $alias = null)\nConstruct a Phar archive object',
'PharData': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, string|null $alias = null, int $format = ?)\nConstruct a non-executable tar or zip archive object',
'PharFileInfo': '(string $filename)\nConstruct a Phar entry object',
'PharException': 'The PharException class provides a phar-specific exception class for try/catch blocks',
'SysvMessageQueue': 'A fully opaque class which replaces a sysvmsg queue resource as of PHP 8',
'SysvSemaphore': 'A fully opaque class which replaces a sysvsem resource as of PHP 8',
'SysvSharedMemory': 'A fully opaque class which replaces a sysvshm resource as of PHP 8',
'SessionHandler': 'SessionHandler is a special class that can be used to expose the current internal PHP session save handler by inheritance',
'SessionHandlerInterface': 'SessionHandlerInterface is an interface which defines the minimal prototype for creating a custom session handler',
'SessionIdInterface': 'SessionIdInterface is an interface which defines optional methods for creating a custom session handler',
'SessionUpdateTimestampHandlerInterface': 'SessionUpdateTimestampHandlerInterface is an interface which defines optional methods for creating a custom session handler',
'Shmop': 'A fully opaque class which replaces shmop resources as of PHP 8',
'AddressInfo': 'A fully opaque class which replaces AddressInfo resources as of PHP 8',
'Socket': 'A fully opaque class which replaces Socket resources as of PHP 8',
'SQLite3': '(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryptionKey = "")\nInstantiates an SQLite3 object and opens an SQLite 3 database',
'SQLite3Result': 'Constructs an SQLite3Result',
'SQLite3Stmt': '(SQLite3 $sqlite3, string $query)\nConstructs an SQLite3Stmt object',
'SQLite3Exception': 'Represents a SQLite3 specific exception',
'PhpToken': '(int $id, string $text, int $line = -1, int $pos = -1)\nReturns a new PhpToken object',
'DeflateContext': 'A fully opaque class which replaces zlib',
'InflateContext': 'A fully opaque class which replaces zlib',
'CURLStringFile': '(string $data, string $postname, string $mime = "application/octet-stream")\nCreate a CURLStringFile object',
'CURLFile': 'This class or CURLStringFile should be used to upload a file with CURLOPT_POSTFIELDS',
'CurlHandle': 'A fully opaque class which replaces curl resources as of PHP 8',
'CurlMultiHandle': 'A fully opaque class which replaces curl_multi resources as of PHP 8',
'CurlShareHandle': 'A fully opaque class which replaces curl_share resources as of PHP 8',
'CurlSharePersistentHandle': 'Represents a persistent cURL "share" handle',
'DOMAttr': '(string $name, string $value = "")\nCreates a new DOMAttr object',
'DOMCdataSection': '(string $data)\nConstructs a new DOMCdataSection object',
'DOMComment': '(string $data = "")\nCreates a new DOMComment object',
'DOMDocument': '(string $version = "1.0", string $encoding = "")\nCreates a new DOMDocument object',
'DOMDocumentFragment': 'Constructs a DOMDocumentFragment object',
'DOMElement': '(string $qualifiedName, string|null $value = null, string $namespace = "")\nCreates a new DOMElement object',
'DOMEntityReference': '(string $name)\nCreates a new DOMEntityReference object',
'DOMImplementation': 'Creates a new DOMImplementation object',
'DOMProcessingInstruction': '(string $name, string $value = "")\nCreates a new DOMProcessingInstruction object',
'DOMText': '(string $data = "")\nCreates a new DOMText object',
'DOMXPath': '(DOMDocument $document, bool $registerNodeNS = true)\nCreates a new DOMXPath object',
'DOMCharacterData': 'Represents nodes with character data',
'DOMDocumentType': 'Each DOMDocument has a doctype attribute whose value is either null or a DOMDocumentType object',
'DOMEntity': 'This interface represents a known entity, either parsed or unparsed, in an XML document',
'DOMException': 'See also ',
'DOMNodeList': 'Represents a live list of nodes',
'Dom\\Attr': 'Dom\\Attr represents an attribute in the Dom\\Element object',
'Dom\\CDATASection': 'The Dom\\CDATASection class inherits from Dom\\Text for textual representation of CData constructs',
'Dom\\CharacterData': 'This is the modern, spec-compliant equivalent of DOMCharacterData',
'Dom\\ChildNode': 'This is the modern, spec-compliant equivalent of DOMChildNode',
'Dom\\Comment': 'This is the modern, spec-compliant equivalent of DOMComment',
'Dom\\Document': 'This is the modern, spec-compliant equivalent of DOMDocument',
'Dom\\DocumentFragment': 'This represents a document fragment, which can be used as a container for other nodes',
'Dom\\DocumentType': 'Each Dom\\Document has a doctype attribute whose value is either null or a Dom\\DocumentType object',
'Dom\\DtdNamedNodeMap': 'Represents a named node map for entities and notation nodes of the DTD',
'Dom\\Element': 'Represents an element',
'Dom\\Entity': 'This is the modern, spec-compliant equivalent of DOMEntity',
'Dom\\EntityReference': 'This is the modern, spec-compliant equivalent of DOMEntityReference',
'Dom\\HTMLCollection': 'Represents a static set of elements',
'Dom\\HTMLDocument': 'Represents an HTML document',
'Dom\\HTMLElement': 'Represents an element in the HTML namespace',
'Dom\namedNodeMap': 'Represents the set of attributes on an element',
'Dom\namespaceInfo': 'This represents immutable information about namespaces of an element',
'Dom\node': 'This is the modern, spec-compliant equivalent of DOMNode',
'Dom\nodeList': 'This is the modern, spec-compliant equivalent of DOMNodeList',
'Dom\\ParentNode': 'This is the modern, spec-compliant equivalent of DOMParentNode',
'Dom\\ProcessingInstruction': 'This is the modern, spec-compliant equivalent of DOMProcessingInstruction',
'Dom\\Text': 'The Dom\\Text class inherits from Dom\\CharacterData and represents a text node',
'Dom\\TokenList': 'Represents a set of tokens in an attribute (e',
'Dom\\XMLDocument': 'Represents an XML document',
'Dom\\XPath': 'This is the modern, spec-compliant equivalent of DOMXPath',
'EnchantBroker': 'A fully opaque class which replaces enchant_broker resources as of PHP 8',
'EnchantDictionary': 'A fully opaque class which replaces enchant_dict resources as of PHP 8',
'GMP': '(int|string $num = ?, int $base = ?)\nCreate GMP number',
'LDAP\\Connection': 'A fully opaque class which replaces a ldap resource as of PHP 8',
'LDAP\\Result': 'A fully opaque class which replaces a ldap result resource as of PHP 8',
'LDAP\\ResultEntry': 'A fully opaque class which replaces a ldap result entry resource as of PHP 8',
'LibXMLError': 'Contains various information about errors thrown by libxml',
'mysqli_result': '(mysqli $mysql, int $result_mode = MYSQLI_STORE_RESULT)\nConstructs a mysqli_result object',
'mysqli_stmt': '(mysqli $mysql, string|null $query = null)\nConstructs a new mysqli_stmt object',
'mysqli_warning': 'Private constructor to disallow direct instantiation',
'mysqli': 'Represents a connection between PHP and a MySQL database',
'mysqli_driver': 'The mysqli_driver class is an instance of the monostate pattern, i',
'mysqli_sql_exception': 'The mysqli exception handling class',
'OpenSSLAsymmetricKey': 'A fully opaque class which replaces OpenSSL key resources as of PHP 8',
'OpenSSLCertificate': 'A fully opaque class which replaces OpenSSL X',
'OpenSSLCertificateSigningRequest': 'A fully opaque class which replaces OpenSSL X',
'Pdo\\Dblib': 'A PDO subclass representing a connection using the DBLib PDO driver',
'Pdo\\Firebird': 'A PDO subclass representing a connection using the Firebird PDO driver',
'Pdo\\Mysql': 'This driver supports a dedicated SQL query parser for the MySQL dialect',
'Pdo\\Odbc': 'A PDO subclass representing a connection using the ODBC PDO driver',
'Pdo\\Pgsql': 'This driver supports a dedicated SQL query parser for the PostgreSQL dialect',
'Pdo\\Sqlite': 'This driver supports a dedicated SQL query parser for the SQLite dialect',
'PgSql\\Connection': 'A fully opaque class which replaces a pgsql link resource as of PHP 8',
'PgSql\\Lob': 'A fully opaque class which replaces a pgsql large object resource as of PHP 8',
'PgSql\\Result': 'A fully opaque class which replaces a pgsql result resource as of PHP 8',
'SimpleXMLElement': '(string $data, int $options = ?, bool $dataIsURL = false, string $namespaceOrPrefix = "", bool $isPrefix = false)\nCreates a new SimpleXMLElement object',
'SimpleXMLIterator': 'The SimpleXMLIterator provides recursive iteration over all nodes of a SimpleXMLElement object',
'SNMP': '(int $version, string $hostname, string $community, int $timeout = -1, int $retries = -1)\nCreates SNMP instance representing session to remote SNMP agent',
'SNMPException': 'Represents an error raised by SNMP',
'SoapClient': '(string|null $wsdl, array $options = [])\nSoapClient constructor',
'SoapFault': '(array|string|null $code, string $string, string|null $actor = null, mixed $details = null, string|null $name = null, mixed $headerFault = null)\nSoapFault constructor',
'SoapHeader': '(string $namespace, string $name, mixed $data = ?, bool $mustunderstand = ?, string $actor = ?)\nSoapHeader constructor',
'SoapParam': '(mixed $data, string $name)\nSoapParam constructor',
'SoapServer': '(string|null $wsdl, array $options = [])\nSoapServer constructor',
'SoapVar': '(mixed $data, int|null $encoding, string|null $typeName = null, string|null $typeNamespace = null, string|null $nodeName = null, string|null $nodeNamespace = null)\nSoapVar constructor',
'SodiumException': 'Exceptions thrown by the sodium functions',
'tidy': '(string|null $filename = null, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false)\nConstructs a new tidy object',
'tidyNode': 'Private constructor to disallow direct instantiation',
'XMLParser': 'A fully opaque class which replaces xml resources as of PHP 8',
'XMLReader': 'The XMLReader extension is an XML Pull parser',
'XSLTProcessor': 'Creates a new XSLTProcessor object',
'ZipArchive': 'A file archive, compressed with Zip',
});
vrana-jush-45d07be/jush-dark.css 0000664 0000000 0000000 00000000531 15226341625 0016613 0 ustar 00root root 0000000 0000000 .jush {
--text-color: #ccc;
--bg-color: #111;
--php-color: #cc9;
--string-color: #e6e;
--string-plain-color: #e6e;
--keyword-color: #acf;
--identifier-color: #f88;
--value-color: #e6e;
--number-color: #0c0;
--attribute-color: #3cc;
--js-bg-color: #036;
--css-bg-color: #404000;
--php-bg-color: #520;
--php-sql-bg-color: #404000;
}
vrana-jush-45d07be/jush-help.wsf 0000664 0000000 0000000 00000004546 15226341625 0016643 0 ustar 00root root 0000000 0000000
vrana-jush-45d07be/jush.css 0000664 0000000 0000000 00000005637 15226341625 0015710 0 ustar 00root root 0000000 0000000 .jush {
--text-color: #000;
--bg-color: #fff;
--php-color: #003;
--string-color: green;
--string-plain-color: #009F00;
--keyword-color: navy;
--identifier-color: red;
--value-color: purple;
--number-color: #007F7F;
--attribute-color: teal;
--js-bg-color: #f0f0ff;
--css-bg-color: #ffffe0;
--php-bg-color: #fff0f0;
--php-sql-bg-color: #ffbbb0;
}
.jush { color: var(--text-color); white-space: pre; }
.jush-htm_com, .jush-com, .jush-com_code, .jush-one, .jush-php_doc, .jush-php_com, .jush-php_one, .jush-js_one, .jush-js_doc { color: gray; }
.jush-php, .jush-php_new, .jush-php_fun { color: var(--php-color); background-color: var(--php-bg-color); }
.jush-php_quo, .jush-php_eot, .jush-js_bac { color: var(--string-color); }
.jush-php_apo, .jush-quo, .jush-quo_one, .jush-apo, .jush-sql_apo, .jush-sqlite_apo, .jush-sql_quo, .jush-sql_eot { color: var(--string-plain-color); }
.jush-php_quo_var, .jush-php_var, .jush-sql_var, .jush-js_bac .jush-js { font-style: italic; }
.jush-php_apo .jush-php_quo_var, .jush-php_apo .jush-php_var { font-style: normal; }
.jush-php_halt2 { background-color: var(--bg-color); color: var(--text-color); }
.jush-tag_css, .jush-att_css .jush-att_quo, .jush-att_css .jush-att_apo, .jush-att_css .jush-att_val { color: var(--text-color); background-color: var(--css-bg-color); }
.jush-tag_js, .jush-att_js .jush-att_quo, .jush-att_js .jush-att_apo, .jush-att_js .jush-att_val, .jush-css_js { color: var(--text-color); background-color: var(--js-bg-color); }
.jush-tag, .jush-xml_tag { color: var(--keyword-color); }
.jush-att, .jush-xml_att, .jush-att_js, .jush-att_css, .jush-att_http { color: var(--attribute-color); }
.jush-att_quo, .jush-att_apo, .jush-att_val { color: var(--value-color); }
.jush-ent { color: var(--value-color); }
.jush-js_key, .jush-js_key .jush-quo, .jush-js_key .jush-apo { color: var(--value-color); }
.jush-js_reg { color: var(--keyword-color); }
.jush-php_sql .jush-php_quo, .jush-php_sql .jush-php_apo,
.jush-php_sqlite .jush-php_quo, .jush-php_sqlite .jush-php_apo,
.jush-php_pgsql .jush-php_quo, .jush-php_pgsql .jush-php_apo,
.jush-php_mssql .jush-php_quo, .jush-php_mssql .jush-php_apo,
.jush-php_oracle .jush-php_quo, .jush-php_oracle .jush-php_apo { background-color: var(--php-sql-bg-color); }
.jush-bac, .jush-php_bac, .jush-bra, .jush-mssql_bra, .jush-sqlite_quo { color: var(--identifier-color); }
.jush-num, .jush-clr { color: var(--number-color); }
.jush a { color: var(--keyword-color); }
.jush a.jush-help { cursor: help; }
.jush-sql a, .jush-sql_code a, .jush-sqlite a, .jush-pgsql a, .jush-mssql a, .jush-oracle a, .jush-simpledb a, .jush-igdb a { font-weight: bold; }
.jush-php_sql .jush-php_quo a, .jush-php_sql .jush-php_apo a { font-weight: normal; }
.jush-tag a, .jush-att a, .jush-apo a, .jush-quo a, .jush-php_apo a, .jush-php_quo a, .jush-php_eot2 a { color: inherit; }
a.jush-custom:link, a.jush-custom:visited { font-weight: normal; color: inherit; }
.jush p { margin: 0; }
vrana-jush-45d07be/modules/ 0000775 0000000 0000000 00000000000 15226341625 0015662 5 ustar 00root root 0000000 0000000 vrana-jush-45d07be/modules/jush-autocomplete-sql.js 0000664 0000000 0000000 00000013512 15226341625 0022467 0 ustar 00root root 0000000 0000000 /** Get callback for autocompletition
* @param string escaped empty identifier, e.g. `` for MySQL or [] for MS SQL
* @param Object> keys are table names, values are lists of columns
* @return Function see autocomplete()
*/
jush.autocompleteSql = function (esc, tablesColumns) {
/**
* key: regular expression; ' ' will be expanded to '\\s+', '\\w' to esc[0]+'?\\w'+esc[1]+'?', '$' will be appended
* value: list of autocomplete words; '?' means to not use the word if it's already in the current query
*/
const keywordsDefault = {
'^': ['SELECT', 'INSERT INTO', 'UPDATE', 'DELETE FROM', 'TRUNCATE', 'EXPLAIN'],
'^EXPLAIN ': ['SELECT'],
'^INSERT ': ['IGNORE'],
'^INSERT .+\\) ': ['?VALUES', 'ON DUPLICATE KEY UPDATE'],
'^UPDATE \\w+ ': ['SET'],
'^UPDATE \\w+ SET .+ ': ['?WHERE'],
'^DELETE FROM \\w+ ': ['WHERE'],
' JOIN \\w+(( AS)? (?!(ON|USING|AS) )\\w+)? ': ['ON', 'USING'],
'\\bSELECT ': ['*', 'DISTINCT'],
'\\bSELECT .*[^,] ': ['?FROM'],
'\\bSELECT (?!.* (WHERE|GROUP BY|HAVING|ORDER BY|LIMIT) ).+ FROM .+ ': ['INNER JOIN', 'LEFT JOIN', '?WHERE'],
'\\bSELECT (?!.* (HAVING|ORDER BY|LIMIT|OFFSET) ).+ FROM .+ ': ['?GROUP BY'],
'\\bSELECT (?!.* (ORDER BY|LIMIT|OFFSET) ).+ FROM .+ ': ['?HAVING'],
'\\bSELECT (?!.* (LIMIT|OFFSET) ).+ FROM .+ ': ['?ORDER BY'], // this matches prefixes without LIMIT|OFFSET and offers ORDER BY if it's not already used in prefix or suffix
'\\bSELECT (?!.* (OFFSET) ).+ FROM .+ ': ['?LIMIT', '?OFFSET'],
' ORDER BY (?!.* (LIMIT|OFFSET) ).+ ': ['DESC'],
};
let forceEscape = false;
/** Get list of strings for autocompletion
* @param string
* @param string
* @param string
* @return Object keys are words, values are offsets
*/
function autocomplete(state, before, after) {
if (/^(one|com|sql_apo|sqlite_apo)$/.test(state)) {
return {};
}
before = before
.replace(/\/\*.*?\*\/|(^|\s)--[^\n]*/s, ' ') // replace comments with whitespace
.replace(/'[^']+'/, '0') // replace string with placeholder
.replace(/.*;/s, '') // strip previous query
.trimStart()
;
after = after.replace(/;.*/s, ''); // strip next query
const query = before + after;
const allTables = Object.keys(tablesColumns);
const usedTables = findTables(query); // tables used by the current query
const uniqueColumns = {};
for (const table of Object.values(usedTables)) {
for (const column of tablesColumns[table]) {
uniqueColumns[column] = 0;
}
}
const columns = Object.keys(uniqueColumns);
if (columns.length > 50) {
columns.length = 0;
}
if (Object.keys(usedTables).length > 1) {
for (const alias in usedTables) {
columns.push(alias + '.');
}
}
const preferred = {
'\\b(FROM|INTO|^UPDATE|JOIN|^TRUNCATE) ': allTables, // all tables including the current ones (self-join)
'\\b(^INSERT|USING) [^(]*\\(([^)]+, )?': columns, // offer columns right after '(' or after ','
'(^UPDATE .+ SET| DUPLICATE KEY UPDATE| BY) (.+, )?': columns,
' (WHERE|HAVING|AND|OR|ON|=) ': columns,
};
keywordsDefault['\\bSELECT( DISTINCT)? (?!.* FROM )(.+, )?'] = columns; // this is not in preferred because we prefer '*'
const context = before.replace(escRe('[\\w`]+$'), ''); // in 'UPDATE tab.`co', context is 'UPDATE tab.'
before = before.replace(escRe('.*[^\\w`]', 's'), ''); // in 'UPDATE tab.`co', before is '`co'
const thisColumns = []; // columns in the current table ('table.')
const match = context.match(escRe('`?(\\w+)`?\\.$'));
if (match) {
let table = match[1];
if (!tablesColumns[table]) {
table = usedTables[table];
}
if (tablesColumns[table]) {
thisColumns.push(...tablesColumns[table]);
preferred['\\.'] = thisColumns;
}
}
forceEscape = query.includes(esc[0]) && !/^\w/.test(before); // if there's any ` in the query, use ` everywhere unless the user starts typing letters
allTables.forEach(addEsc);
columns.forEach(addEsc);
thisColumns.forEach(addEsc);
const ac = {};
for (const keywords of [preferred, keywordsDefault]) {
for (const re in keywords) {
if (context.match(escRe(re.replace(/ /g, '\\s+').replace(/\\w\+/g, '`?\\w+`?') + '$', 'is'))) {
for (let keyword of keywords[re]) {
if (keyword[0] == '?') {
keyword = keyword.substring(1);
if (query.match(new RegExp('\\s+' + keyword + '\\s+', 'i'))) {
continue;
}
}
if (keyword.length > before.length && keyword.toUpperCase().startsWith(before.toUpperCase())) {
const isCol = (keywords[re] == columns || keywords[re] == thisColumns);
ac[keyword + (isCol ? '' : ' ')] = before.length;
}
}
}
}
}
return ac;
}
function addEsc(val, key, array) {
if (forceEscape || !/^[a-z_]\w*\.?$/i.test(val)) {
array[key] = esc[0] + val.replace(/\.?$/, esc[1] + '$&');
}
}
/** Change odd ` to esc[0], even to esc[1] */
function escRe(re, flags) {
let i = 0;
return new RegExp(re.replace(/`/g, () => (esc[0] == '[' ? '\\' : '') + esc[i++ % 2]), flags);
}
/** @return Object key is alias, value is actual table */
function findTables(query) {
const matches = query.matchAll(escRe('\\b(FROM|JOIN|INTO|UPDATE)\\s+(\\w+|`.+?`)((\\s+AS)?\\s+((?!(LEFT|INNER|JOIN|ON|USING|WHERE|GROUP|HAVING|ORDER|LIMIT)\\b)\\w+|`.+?`))?', 'gi')); //! handle `abc``def`
const result = {};
for (const match of matches) {
const table = match[2].replace(escRe('^`|`$', 'g'), '');
const alias = (match[5] ? match[5].replace(escRe('^`|`$', 'g'), '') : table);
if (tablesColumns[table]) {
result[alias] = table;
}
}
if (!Object.keys(result).length) {
for (const table in tablesColumns) {
result[table] = table;
}
}
return result;
}
// we open the autocomplete on word character, space, '(', '.' and '`'; textarea also triggers it on Backspace and Ctrl+Space
autocomplete.openBy = escRe('^[\\w`(. ]$'); //! ignore . in 1.23
return autocomplete;
};
vrana-jush-45d07be/modules/jush-cnf.js 0000664 0000000 0000000 00000020407 15226341625 0017740 0 ustar 00root root 0000000 0000000 jush.tr.cnf = { quo_one: /"/, one: /#/, cnf_http: /((?:^|\n)\s*)(RequestHeader|Header|CacheIgnoreHeaders)([ \t]+|$)/i, cnf_php: /((?:^|\n)\s*)(PHPIniDir)([ \t]+|$)/i, cnf_phpini: /((?:^|\n)\s*)(php_value|php_flag|php_admin_value|php_admin_flag)([ \t]+|$)/i };
jush.tr.quo_one = { esc: /\\/, _1: /"|(?=\n)/ };
jush.tr.cnf_http = { apo: /'/, quo: /"/, _1: /(?=\n)/ };
jush.tr.cnf_php = { _1: /()/ };
jush.tr.cnf_phpini = { cnf_phpini_val: /[ \t]/ };
jush.tr.cnf_phpini_val = { apo: /'/, quo: /"/, _2: /(?=\n)/ };
jush.urls.cnf_http = 'https://httpd.apache.org/docs/current/mod/$key.html#$val';
jush.urls.cnf_php = 'https://www.php.net/$key';
jush.urls.cnf_phpini = 'https://www.php.net/configuration.changes#$key';
jush.links.cnf_http = { 'mod_cache': /CacheIgnoreHeaders/i, 'mod_headers': /.+/ };
jush.links.cnf_php = { 'configuration.file': /.+/ };
jush.links.cnf_phpini = { 'configuration.changes.apache': /.+/ };
jush.build_links2('cnf', 'https://httpd.apache.org/docs/current/mod/$key.html#$1', /((?:^|\n)\s*(?:<)?)/, /(\b)/gi, {
'beos': /(MaxRequestsPerThread)/,
'core': /(AcceptFilter|AcceptPathInfo|AccessFileName|AddDefaultCharset|AddOutputFilterByType|AllowEncodedSlashes|AllowOverride|AuthName|AuthType|CGIMapExtension|ContentDigest|DefaultType|Directory|DirectoryMatch|DocumentRoot|EnableMMAP|EnableSendfile|ErrorDocument|ErrorLog|FileETag|Files|FilesMatch|ForceType|HostnameLookups|IfDefine|IfModule|Include|KeepAlive|KeepAliveTimeout|Limit|LimitExcept|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine|LimitXMLRequestBody|Location|LocationMatch|LogLevel|MaxKeepAliveRequests|NameVirtualHost|Options|Require|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScriptInterpreterSource|ServerAdmin|ServerAlias|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|SetHandler|SetInputFilter|SetOutputFilter|TimeOut|TraceEnable|UseCanonicalName|UseCanonicalPhysicalPort|VirtualHost)/,
'mod_actions': /(Action|Script)/,
'mod_alias': /(Alias|AliasMatch|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ScriptAlias|ScriptAliasMatch)/,
'mod_auth_basic': /(AuthBasicAuthoritative|AuthBasicProvider)/,
'mod_auth_digest': /(AuthDigestAlgorithm|AuthDigestDomain|AuthDigestNcCheck|AuthDigestNonceFormat|AuthDigestNonceLifetime|AuthDigestProvider|AuthDigestQop|AuthDigestShmemSize)/,
'mod_authn_alias': /(AuthnProviderAlias)/,
'mod_authn_anon': /(Anonymous|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID|Anonymous_VerifyEmail)/,
'mod_authn_dbd': /(AuthDBDUserPWQuery|AuthDBDUserRealmQuery)/,
'mod_authn_dbm': /(AuthDBMType|AuthDBMUserFile)/,
'mod_authn_default': /(AuthDefaultAuthoritative)/,
'mod_authn_file': /(AuthUserFile)/,
'mod_authnz_ldap': /(AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPRemoteUserAttribute|AuthLDAPRemoteUserIsDN|AuthLDAPUrl|AuthzLDAPAuthoritative)/,
'mod_authz_dbm': /(AuthDBMGroupFile|AuthzDBMAuthoritative|AuthzDBMType)/,
'mod_authz_default': /(AuthzDefaultAuthoritative)/,
'mod_authz_groupfile': /(AuthGroupFile|AuthzGroupFileAuthoritative)/,
'mod_authz_host': /(Allow|Deny|Order)/,
'mod_authz_owner': /(AuthzOwnerAuthoritative)/,
'mod_authz_user': /(AuthzUserAuthoritative)/,
'mod_autoindex': /(AddAlt|AddAltByEncoding|AddAltByType|AddDescription|AddIcon|AddIconByEncoding|AddIconByType|DefaultIcon|HeaderName|IndexHeadInsert|IndexIgnore|IndexOptions|IndexOrderDefault|IndexStyleSheet|ReadmeName)/,
'mod_cache': /(CacheDefaultExpire|CacheDisable|CacheEnable|CacheIgnoreCacheControl|CacheIgnoreNoLastMod|CacheIgnoreQueryString|CacheLastModifiedFactor|CacheMaxExpire|CacheStoreNoStore|CacheStorePrivate)/,
'mod_cern_meta': /(MetaDir|MetaFiles|MetaSuffix)/,
'mod_cgi': /(ScriptLog|ScriptLogBuffer|ScriptLogLength)/,
'mod_cgid': /(ScriptSock)/,
'mod_dav': /(Dav|DavDepthInfinity|DavMinTimeout)/,
'mod_dav_fs': /(DavLockDB)/,
'mod_dav_lock': /(DavGenericLockDB)/,
'mod_dbd': /(DBDExptime|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver)/,
'mod_deflate': /(DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateMemLevel|DeflateWindowSize)/,
'mod_dir': /(DirectoryIndex|DirectorySlash)/,
'mod_disk_cache': /(CacheDirLength|CacheDirLevels|CacheMaxFileSize|CacheMinFileSize|CacheRoot)/,
'mod_dumpio': /(DumpIOInput|DumpIOLogLevel|DumpIOOutput)/,
'mod_echo': /(ProtocolEcho)/,
'mod_env': /(PassEnv|SetEnv|UnsetEnv)/,
'mod_example': /(Example)/,
'mod_expires': /(ExpiresActive|ExpiresByType|ExpiresDefault)/,
'mod_ext_filter': /(ExtFilterDefine|ExtFilterOptions)/,
'mod_file_cache': /(CacheFile|MMapFile)/,
'mod_filter': /(FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace)/,
'mod_charset_lite': /(CharsetDefault|CharsetOptions|CharsetSourceEnc)/,
'mod_ident': /(IdentityCheck|IdentityCheckTimeout)/,
'mod_imagemap': /(ImapBase|ImapDefault|ImapMenu)/,
'mod_include': /(SSIEnableAccess|SSIEndTag|SSIErrorMsg|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|XBitHack)/,
'mod_info': /(AddModuleInfo)/,
'mod_isapi': /(ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer)/,
'mod_ldap': /(LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionTimeout|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPSharedCacheFile|LDAPSharedCacheSize|LDAPTrustedClientCert|LDAPTrustedGlobalCert|LDAPTrustedMode|LDAPVerifyServerCert)/,
'mod_log_config': /(BufferedLogs|CookieLog|CustomLog|LogFormat|TransferLog)/,
'mod_log_forensic': /(ForensicLog)/,
'mod_mem_cache': /(MCacheMaxObjectCount|MCacheMaxObjectSize|MCacheMaxStreamingBuffer|MCacheMinObjectSize|MCacheRemovalAlgorithm|MCacheSize)/,
'mod_mime': /(AddCharset|AddEncoding|AddHandler|AddInputFilter|AddLanguage|AddOutputFilter|AddType|DefaultLanguage|ModMimeUsePathInfo|MultiviewsMatch|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|TypesConfig)/,
'mod_mime_magic': /(MimeMagicFile)/,
'mod_negotiation': /(CacheNegotiatedDocs|ForceLanguagePriority|LanguagePriority)/,
'mod_nw_ssl': /(NWSSLTrustedCerts|NWSSLUpgradeable|SecureListen)/,
'mod_proxy': /(AllowCONNECT|BalancerMember|NoProxy|Proxy|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyFtpDirCharset|ProxyIOBufferSize|ProxyMatch|ProxyMaxForwards|ProxyPass|ProxyPassInterpolateEnv|ProxyPassMatch|ProxyPassReverse|ProxyPassReverseCookieDomain|ProxyPassReverseCookiePath|ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxySet|ProxyStatus|ProxyTimeout|ProxyVia)/,
'mod_rewrite': /(RewriteBase|RewriteCond|RewriteEngine|RewriteLock|RewriteLog|RewriteLogLevel|RewriteMap|RewriteOptions|RewriteRule)/,
'mod_setenvif': /(BrowserMatch|BrowserMatchNoCase|SetEnvIf|SetEnvIfNoCase)/,
'mod_so': /(LoadFile|LoadModule)/,
'mod_speling': /(CheckCaseOnly|CheckSpelling)/,
'mod_ssl': /(SSLCACertificateFile|SSLCACertificatePath|SSLCADNRequestFile|SSLCADNRequestPath|SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLCryptoDevice|SSLEngine|SSLHonorCipherOrder|SSLMutex|SSLOptions|SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCipherSuite|SSLProxyEngine|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRequire|SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLUserName|SSLVerifyClient|SSLVerifyDepth)/,
'mod_status': /(ExtendedStatus|SeeRequestTail)/,
'mod_substitute': /(Substitute)/,
'mod_suexec': /(SuexecUserGroup)/,
'mod_userdir': /(UserDir)/,
'mod_usertrack': /(CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking)/,
'mod_version': /(IfVersion)/,
'mod_vhost_alias': /(VirtualDocumentRoot|VirtualDocumentRootIP|VirtualScriptAlias|VirtualScriptAliasIP)/,
'mpm_common': /(AcceptMutex|ChrootDir|CoreDumpDirectory|EnableExceptionHook|GracefulShutdownTimeout|Group|Listen|ListenBackLog|LockFile|MaxClients|MaxMemFree|MaxRequestsPerChild|MaxSpareThreads|MinSpareThreads|PidFile|ReceiveBufferSize|ScoreBoardFile|SendBufferSize|ServerLimit|StartServers|StartThreads|ThreadLimit|ThreadsPerChild|ThreadStackSize|User)/,
'mpm_netware': /(MaxThreads)/,
'mpm_winnt': /(Win32DisableAcceptEx)/,
'prefork': /(MaxSpareServers|MinSpareServers)/,
});
vrana-jush-45d07be/modules/jush-css.js 0000664 0000000 0000000 00000015146 15226341625 0017766 0 ustar 00root root 0000000 0000000 jush.tr.css = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at: /(@)([^;\s{]+)/, css_pro: /\{/, _2: /(<)(\/style)(>)/i };
jush.tr.css_at = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at2: /\{/, _1: /;/ };
jush.tr.css_at2 = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at: /@/, css_pro: /\{/, _2: /}/ };
jush.tr.css_pro = { php: jush.php, com: /\/\*/, css_val: /(\s*)([-\w]+)(\s*:)/, _1: /}/ }; //! misses e.g. margin/*-left*/:
jush.tr.css_val = { php: jush.php, quo: /"/, apo: /'/, css_js: /expression\s*\(/i, com: /\/\*/, clr: /#/, num: /[-+]?[0-9]*\.?[0-9]+(?:em|ex|px|in|cm|mm|pt|pc|%)?/, _2: /}/, _1: /;|$/ };
jush.tr.css_js = { php: jush.php, css_js: /\(/, _1: /\)/ };
jush.tr.clr = { _1: /(?=[^a-fA-F0-9])/ };
jush.urls.css_at = 'https://developer.mozilla.org/en-US/docs/Web/CSS/$key';
jush.urls.css_val = jush.urls.css_at;
jush.links.css_at = {
'@$val': /^(charset|color-profile|container|counter-style|document|font-face|font-feature-values|font-palette-values|import|keyframes|layer|media|namespace|page|position-try|property|scope|starting-style|supports|view-transition)$/i
};
jush.links.css_val = {
'$val': /^(accent-color|align-(content|items|self)|alignment-baseline|all|anchor-name|animation(-composition|-delay|-direction|-duration|-fill-mode|-iteration-count|-name|-play-state|-range(-end|-start)?|-timeline|-timing-function)?|appearance|aspect-ratio|backdrop-filter|backface-visibility|background(-attachment|-blend-mode|-clip|-color|-image|-origin|-position(-x|-y)?|-repeat|-size)?|block-size|border(-block(-color|-end(-color|-style|-width)?|-start(-color|-style|-width)?|-style|-width)?|-bottom(-color|-left-radius|-right-radius|-style|-width)?|-collapse|-color|-end-end-radius|-end-start-radius|-image(-outset|-repeat|-slice|-source|-width)?|-inline(-color|-end(-color|-style|-width)?|-start(-color|-style|-width)?|-style|-width)?|-left(-color|-style|-width)?|-radius|-right(-color|-style|-width)?|-spacing|-start-end-radius|-start-start-radius|-style|-top(-color|-left-radius|-right-radius|-style|-width)?|-width)?|bottom|box-(align|decoration-break|direction|flex(-group)?|lines|ordinal-group|orient|pack|shadow|sizing)|break-(after|before|inside)|caption-side|caret-color|clear|clip(-path|-rule)?|color(-interpolation(-filters)?|-scheme)?|column-(count|fill|gap|rule(-color|-style|-width)?|span|width)|columns|contain(-intrinsic-block-size|-intrinsic-height|-intrinsic-inline-size|-intrinsic-size|-intrinsic-width)?|container(-name|-type)?|content(-visibility)?|counter-(increment|reset|set)|cursor|cx|cy|d|direction|display|dominant-baseline|empty-cells|field-sizing|fill(-opacity|-rule)?|filter|flex(-basis|-direction|-flow|-grow|-shrink|-wrap)?|float|flood-(color|opacity)|font(-family|-feature-settings|-kerning|-language-override|-optical-sizing|-palette|-size(-adjust)?|-smooth|-stretch|-style|-synthesis(-position|-small-caps|-style|-weight)?|-variant(-alternates|-caps|-east-asian|-emoji|-ligatures|-numeric|-position)?|-variation-settings|-weight)?|forced-color-adjust|gap|grid(-area|-auto-columns|-auto-flow|-auto-rows|-column(-end|-start)?|-row(-end|-start)?|-template(-areas|-columns|-rows)?)?|hanging-punctuation|height|hyphenate-(character|limit-chars)|hyphens|image-(orientation|rendering|resolution)|initial-letter|inline-size|inset(-block(-end|-start)?|-inline(-end|-start)?)?|interpolate-size|isolation|justify-(content|items|self)|left|letter-spacing|lighting-color|line-(break|clamp|height(-step)?)|list-style(-image|-position|-type)?|margin(-block(-end|-start)?|-bottom|-inline(-end|-start)?|-left|-right|-top|-trim)?|marker(-end|-mid|-start)?|mask(-border(-mode|-outset|-repeat|-slice|-source|-width)?|-clip|-composite|-image|-mode|-origin|-position|-repeat|-size|-type)?|math-(depth|shift|style)|max-(block-size|height|inline-size|width)|min-(block-size|height|inline-size|width)|mix-blend-mode|object-(fit|position)|offset(-anchor|-distance|-path|-position|-rotate)?|opacity|order|orphans|outline(-color|-offset|-style|-width)?|overflow(-anchor|-block|-clip-margin|-inline|-wrap|-x|-y)?|overlay|overscroll-behavior(-block|-inline|-x|-y)?|padding(-block(-end|-start)?|-bottom|-inline(-end|-start)?|-left|-right|-top)?|page(-break-after|-break-before|-break-inside)?|paint-order|perspective(-origin)?|place-(content|items|self)|pointer-events|position(-anchor|-area|-try(-fallbacks|-order)?|-visibility)?|print-color-adjust|quotes|r|resize|right|rotate|row-gap|ruby-(align|position)|rx|ry|scale|scroll-(behavior|margin(-block(-end|-start)?|-bottom|-inline(-end|-start)?|-left|-right|-top)?|marker-group|padding(-block(-end|-start)?|-bottom|-inline(-end|-start)?|-left|-right|-top)?|snap-(align|stop|type)|timeline(-axis|-name)?)|scrollbar-(color|gutter|width)|shape-(image-threshold|margin|outside|rendering)|speak-as|stop-(color|opacity)|stroke(-dasharray|-dashoffset|-linecap|-linejoin|-miterlimit|-opacity|-width)?|tab-size|table-layout|text-(align(-last)?|anchor|box(-edge|-trim)?|combine-upright|decoration(-color|-line|-skip(-ink)?|-style|-thickness)?|emphasis(-color|-position|-style)?|indent|justify|orientation|overflow|rendering|shadow|size-adjust|spacing-trim|transform|underline-(offset|position)|wrap(-mode|-style)?)|timeline-scope|top|touch-action|transform(-box|-origin|-style)?|transition(-behavior|-delay|-duration|-property|-timing-function)?|translate|unicode-bidi|user-(modify|select)|vector-effect|vertical-align|view-(timeline(-axis|-inset|-name)?|transition-name)|visibility|white-space(-collapse)?|widows|width|will-change|word-(break|spacing)|writing-mode|x|y|z-index|zoom)$/i
};
jush.build_links2('css', jush.urls.css_at, /(:)/, /((?![-\w]))/gi, {
'_colon_$1': /(?