@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/php.json

@@ -0,0 +1,726 @@
+{
+  "language": "php",
+  "definitions": {
+    "array": {
+      "signature": "array",
+      "description": "An ordered map in PHP. Arrays can hold any combination of values indexed by integers or strings. They serve as lists, hash tables, dictionaries, collections, stacks, and queues.",
+      "type": "type",
+      "module": "Core",
+      "members": {
+        "array_push": { "signature": "array_push(array &$array, mixed ...$values): int", "description": "Pushes one or more elements onto the end of an array. Returns the new number of elements.", "type": "function" },
+        "array_pop": { "signature": "array_pop(array &$array): mixed", "description": "Pops and returns the last element of the array, shortening it by one.", "type": "function" },
+        "array_shift": { "signature": "array_shift(array &$array): mixed", "description": "Shifts the first value off the array and returns it, re-indexing numeric keys.", "type": "function" },
+        "array_unshift": { "signature": "array_unshift(array &$array, mixed ...$values): int", "description": "Prepends one or more elements to the beginning of an array.", "type": "function" },
+        "array_merge": { "signature": "array_merge(array ...$arrays): array", "description": "Merges one or more arrays. Numeric keys are re-indexed; string keys are overwritten by later arrays.", "type": "function" },
+        "array_combine": { "signature": "array_combine(array $keys, array $values): array", "description": "Creates an array by using one array for keys and another for its values.", "type": "function" },
+        "array_map": { "signature": "array_map(?callable $callback, array $array, array ...$arrays): array", "description": "Applies the callback to each element and returns a new array of results.", "type": "function" },
+        "array_filter": { "signature": "array_filter(array $array, ?callable $callback = null, int $mode = 0): array", "description": "Filters elements using a callback. Without callback, removes falsy values.", "type": "function" },
+        "array_reduce": { "signature": "array_reduce(array $array, callable $callback, mixed $initial = null): mixed", "description": "Iteratively reduces the array to a single value using a callback.", "type": "function" },
+        "array_keys": { "signature": "array_keys(array $array, mixed $filter_value = null, bool $strict = false): array", "description": "Returns all the keys or a subset of the keys of an array.", "type": "function" },
+        "array_values": { "signature": "array_values(array $array): array", "description": "Returns all the values from the array with numeric indexing.", "type": "function" },
+        "array_unique": { "signature": "array_unique(array $array, int $flags = SORT_STRING): array", "description": "Removes duplicate values from an array, preserving the first occurrence.", "type": "function" },
+        "array_reverse": { "signature": "array_reverse(array $array, bool $preserve_keys = false): array", "description": "Returns an array with elements in reverse order.", "type": "function" },
+        "array_slice": { "signature": "array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array", "description": "Extracts a slice of the array.", "type": "function" },
+        "array_splice": { "signature": "array_splice(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array", "description": "Removes a portion of the array and optionally replaces it. Returns removed elements.", "type": "function" },
+        "array_search": { "signature": "array_search(mixed $needle, array $haystack, bool $strict = false): int|string|false", "description": "Searches the array for a value and returns the corresponding key.", "type": "function" },
+        "in_array": { "signature": "in_array(mixed $needle, array $haystack, bool $strict = false): bool", "description": "Checks if a value exists in an array.", "type": "function" },
+        "count": { "signature": "count(Countable|array $value, int $mode = COUNT_NORMAL): int", "description": "Counts all elements in an array or Countable object.", "type": "function" },
+        "sort": { "signature": "sort(array &$array, int $flags = SORT_REGULAR): true", "description": "Sorts an array in ascending order by value, re-indexing keys.", "type": "function" },
+        "usort": { "signature": "usort(array &$array, callable $callback): true", "description": "Sorts an array by values using a user-defined comparison function.", "type": "function" },
+        "array_walk": { "signature": "array_walk(array|object &$array, callable $callback, mixed $arg = null): true", "description": "Applies a user function to every member of an array.", "type": "function" },
+        "array_key_exists": { "signature": "array_key_exists(string|int $key, array $array): bool", "description": "Checks if the given key or index exists in the array.", "type": "function" },
+        "array_column": { "signature": "array_column(array $array, int|string|null $column_key, int|string|null $index_key = null): array", "description": "Returns the values from a single column of a multi-dimensional array.", "type": "function" },
+        "array_chunk": { "signature": "array_chunk(array $array, int $length, bool $preserve_keys = false): array", "description": "Splits an array into chunks of the specified size.", "type": "function" },
+        "array_diff": { "signature": "array_diff(array $array, array ...$arrays): array", "description": "Computes the difference of arrays using values for comparison.", "type": "function" },
+        "array_intersect": { "signature": "array_intersect(array $array, array ...$arrays): array", "description": "Computes the intersection of arrays using values for comparison.", "type": "function" },
+        "array_fill": { "signature": "array_fill(int $start_index, int $count, mixed $value): array", "description": "Fills an array with values, specifying start index and number of entries.", "type": "function" },
+        "compact": { "signature": "compact(array|string $var_name, array|string ...$var_names): array", "description": "Creates an array containing variables and their values.", "type": "function" },
+        "range": { "signature": "range(string|int|float $start, string|int|float $end, int|float $step = 1): array", "description": "Creates an array containing a range of elements.", "type": "function" }
+      }
+    },
+    "string": {
+      "signature": "string",
+      "description": "A series of bytes in PHP. Strings are binary-safe and can be up to 2GB. String literals can be specified in four ways: single-quoted, double-quoted, heredoc, and nowdoc.",
+      "type": "type",
+      "module": "Core",
+      "members": {
+        "strlen": { "signature": "strlen(string $string): int", "description": "Returns the length of the given string in bytes.", "type": "function" },
+        "strpos": { "signature": "strpos(string $haystack, string $needle, int $offset = 0): int|false", "description": "Finds the position of the first occurrence of a substring.", "type": "function" },
+        "substr": { "signature": "substr(string $string, int $offset, ?int $length = null): string", "description": "Returns the portion of string specified by offset and length.", "type": "function" },
+        "str_replace": { "signature": "str_replace(array|string $search, array|string $replace, string|array $subject, int &$count = null): string|array", "description": "Replaces all occurrences of the search string with the replacement.", "type": "function" },
+        "str_contains": { "signature": "str_contains(string $haystack, string $needle): bool", "description": "(PHP 8.0+) Determines if a string contains a given substring.", "type": "function" },
+        "str_starts_with": { "signature": "str_starts_with(string $haystack, string $needle): bool", "description": "(PHP 8.0+) Checks if a string starts with a given substring.", "type": "function" },
+        "str_ends_with": { "signature": "str_ends_with(string $haystack, string $needle): bool", "description": "(PHP 8.0+) Checks if a string ends with a given substring.", "type": "function" },
+        "strtolower": { "signature": "strtolower(string $string): string", "description": "Returns a string with all ASCII alphabetic characters converted to lowercase.", "type": "function" },
+        "strtoupper": { "signature": "strtoupper(string $string): string", "description": "Returns a string with all ASCII alphabetic characters converted to uppercase.", "type": "function" },
+        "trim": { "signature": "trim(string $string, string $characters = \" \\n\\r\\t\\v\\0\"): string", "description": "Strips whitespace or other characters from both ends of a string.", "type": "function" },
+        "explode": { "signature": "explode(string $separator, string $string, int $limit = PHP_INT_MAX): array", "description": "Splits a string by a string delimiter and returns an array.", "type": "function" },
+        "implode": { "signature": "implode(string $separator, array $array): string", "description": "Joins array elements with a glue string.", "type": "function" },
+        "str_pad": { "signature": "str_pad(string $string, int $length, string $pad_string = ' ', int $pad_type = STR_PAD_RIGHT): string", "description": "Pads a string to a certain length with another string.", "type": "function" },
+        "str_repeat": { "signature": "str_repeat(string $string, int $times): string", "description": "Repeats a string a given number of times.", "type": "function" },
+        "sprintf": { "signature": "sprintf(string $format, mixed ...$values): string", "description": "Returns a string produced according to a format string.", "type": "function" },
+        "htmlspecialchars": { "signature": "htmlspecialchars(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE, ?string $encoding = null, bool $double_encode = true): string", "description": "Converts special characters to HTML entities for safe output.", "type": "function" },
+        "urlencode": { "signature": "urlencode(string $string): string", "description": "URL-encodes a string, replacing special characters with percent-encoded values.", "type": "function" },
+        "base64_encode": { "signature": "base64_encode(string $string): string", "description": "Encodes the given data with Base64.", "type": "function" }
+      }
+    },
+    "DateTime": {
+      "signature": "class DateTime implements DateTimeInterface",
+      "description": "Representation of date and time. Allows manipulation of dates and times with timezone support. For immutable operations, use DateTimeImmutable instead.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "format": { "signature": "DateTime::format(string $format): string", "description": "Returns date formatted according to given format. Common: Y-m-d, H:i:s, U (timestamp), c (ISO 8601).", "type": "method" },
+        "modify": { "signature": "DateTime::modify(string $modifier): DateTime|false", "description": "Alters the timestamp by incrementing or decrementing in a format accepted by strtotime(). E.g. '+1 day', '-2 months'.", "type": "method" },
+        "diff": { "signature": "DateTime::diff(DateTimeInterface $targetObject, bool $absolute = false): DateInterval", "description": "Returns the difference between two DateTime objects as a DateInterval.", "type": "method" },
+        "getTimestamp": { "signature": "DateTime::getTimestamp(): int", "description": "Gets the Unix timestamp for the DateTime object.", "type": "method" },
+        "createFromFormat": { "signature": "static DateTime::createFromFormat(string $format, string $datetime, ?DateTimeZone $timezone = null): DateTime|false", "description": "Parses a date string according to a specified format. Returns false on failure.", "type": "method" },
+        "setTimezone": { "signature": "DateTime::setTimezone(DateTimeZone $timezone): DateTime", "description": "Sets the time zone for the DateTime object.", "type": "method" },
+        "add": { "signature": "DateTime::add(DateInterval $interval): DateTime", "description": "Modifies the DateTime object by adding the given DateInterval.", "type": "method" },
+        "sub": { "signature": "DateTime::sub(DateInterval $interval): DateTime", "description": "Modifies the DateTime object by subtracting the given DateInterval.", "type": "method" }
+      }
+    },
+    "DateTimeImmutable": {
+      "signature": "class DateTimeImmutable implements DateTimeInterface",
+      "description": "Immutable representation of date and time. Unlike DateTime, modification methods return a new instance instead of modifying the existing one.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "format": { "signature": "DateTimeImmutable::format(string $format): string", "description": "Returns date formatted according to given format.", "type": "method" },
+        "modify": { "signature": "DateTimeImmutable::modify(string $modifier): DateTimeImmutable|false", "description": "Creates a new object with modified timestamp. The original is not changed.", "type": "method" },
+        "diff": { "signature": "DateTimeImmutable::diff(DateTimeInterface $targetObject, bool $absolute = false): DateInterval", "description": "Returns the difference between two DateTimeInterface objects.", "type": "method" },
+        "getTimestamp": { "signature": "DateTimeImmutable::getTimestamp(): int", "description": "Gets the Unix timestamp.", "type": "method" },
+        "createFromFormat": { "signature": "static DateTimeImmutable::createFromFormat(string $format, string $datetime, ?DateTimeZone $timezone = null): DateTimeImmutable|false", "description": "Parses a date string according to a specified format.", "type": "method" },
+        "setTimezone": { "signature": "DateTimeImmutable::setTimezone(DateTimeZone $timezone): DateTimeImmutable", "description": "Returns a new instance with the specified time zone.", "type": "method" },
+        "add": { "signature": "DateTimeImmutable::add(DateInterval $interval): DateTimeImmutable", "description": "Returns a new object with the given DateInterval added.", "type": "method" },
+        "sub": { "signature": "DateTimeImmutable::sub(DateInterval $interval): DateTimeImmutable", "description": "Returns a new object with the given DateInterval subtracted.", "type": "method" }
+      }
+    },
+    "SplStack": {
+      "signature": "class SplStack extends SplDoublyLinkedList",
+      "description": "Provides the main functionalities of a stack implemented using a doubly linked list. Iteration is LIFO (Last In, First Out).",
+      "type": "class",
+      "module": "SPL",
+      "members": {
+        "push": { "signature": "SplStack::push(mixed $value): void", "description": "Pushes an element at the top of the stack.", "type": "method" },
+        "pop": { "signature": "SplStack::pop(): mixed", "description": "Pops a node from the top of the stack.", "type": "method" },
+        "top": { "signature": "SplStack::top(): mixed", "description": "Peeks at the top of the stack without removing it.", "type": "method" },
+        "isEmpty": { "signature": "SplStack::isEmpty(): bool", "description": "Checks whether the stack is empty.", "type": "method" },
+        "count": { "signature": "SplStack::count(): int", "description": "Returns the number of elements in the stack.", "type": "method" }
+      }
+    },
+    "SplQueue": {
+      "signature": "class SplQueue extends SplDoublyLinkedList",
+      "description": "Provides the main functionalities of a queue implemented using a doubly linked list. Iteration is FIFO (First In, First Out).",
+      "type": "class",
+      "module": "SPL",
+      "members": {
+        "enqueue": { "signature": "SplQueue::enqueue(mixed $value): void", "description": "Adds an element to the end of the queue.", "type": "method" },
+        "dequeue": { "signature": "SplQueue::dequeue(): mixed", "description": "Dequeues a node from the front of the queue.", "type": "method" },
+        "bottom": { "signature": "SplQueue::bottom(): mixed", "description": "Peeks at the node from the beginning of the queue.", "type": "method" },
+        "isEmpty": { "signature": "SplQueue::isEmpty(): bool", "description": "Checks whether the queue is empty.", "type": "method" },
+        "count": { "signature": "SplQueue::count(): int", "description": "Returns the number of elements in the queue.", "type": "method" }
+      }
+    },
+    "ArrayObject": {
+      "signature": "class ArrayObject implements IteratorAggregate, ArrayAccess, Serializable, Countable",
+      "description": "Allows objects to work as arrays. Provides array-like access with bracket syntax and iteration, with the flexibility of an object.",
+      "type": "class",
+      "module": "SPL",
+      "members": {
+        "offsetGet": { "signature": "ArrayObject::offsetGet(mixed $key): mixed", "description": "Returns the value at the specified index.", "type": "method" },
+        "offsetSet": { "signature": "ArrayObject::offsetSet(mixed $key, mixed $value): void", "description": "Sets the value at the specified index.", "type": "method" },
+        "offsetExists": { "signature": "ArrayObject::offsetExists(mixed $key): bool", "description": "Returns whether the requested index exists.", "type": "method" },
+        "offsetUnset": { "signature": "ArrayObject::offsetUnset(mixed $key): void", "description": "Unsets the value at the specified index.", "type": "method" },
+        "append": { "signature": "ArrayObject::append(mixed $value): void", "description": "Appends the value as the last element.", "type": "method" },
+        "count": { "signature": "ArrayObject::count(): int", "description": "Returns the number of public properties or array elements.", "type": "method" },
+        "getArrayCopy": { "signature": "ArrayObject::getArrayCopy(): array", "description": "Creates a copy of the ArrayObject as a standard array.", "type": "method" },
+        "getIterator": { "signature": "ArrayObject::getIterator(): ArrayIterator", "description": "Creates an external iterator for iterating over the object.", "type": "method" }
+      }
+    },
+    "strlen": {
+      "signature": "strlen(string $string): int",
+      "description": "Returns the length of the given string in bytes. For multi-byte character length, use mb_strlen() instead.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The string being measured for length" }
+      ],
+      "returns": "int"
+    },
+    "strpos": {
+      "signature": "strpos(string $haystack, string $needle, int $offset = 0): int|false",
+      "description": "Finds the numeric position of the first occurrence of needle in the haystack string.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "haystack", "type": "string", "description": "The string to search in" },
+        { "name": "needle", "type": "string", "description": "The string to search for" },
+        { "name": "offset", "type": "int", "description": "Search start position (default 0)" }
+      ],
+      "returns": "int|false"
+    },
+    "substr": {
+      "signature": "substr(string $string, int $offset, ?int $length = null): string",
+      "description": "Returns the portion of string specified by the offset and length parameters.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The input string" },
+        { "name": "offset", "type": "int", "description": "Start position; negative counts from end" },
+        { "name": "length", "type": "?int", "description": "Maximum number of characters to return" }
+      ],
+      "returns": "string"
+    },
+    "str_replace": {
+      "signature": "str_replace(array|string $search, array|string $replace, string|array $subject, int &$count = null): string|array",
+      "description": "Replaces all occurrences of the search string with the replacement string. Works with both strings and arrays.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "search", "type": "array|string", "description": "The value(s) being searched for" },
+        { "name": "replace", "type": "array|string", "description": "The replacement value(s)" },
+        { "name": "subject", "type": "string|array", "description": "The string or array being searched and replaced on" },
+        { "name": "count", "type": "int", "description": "If passed, set to the number of replacements performed" }
+      ],
+      "returns": "string|array"
+    },
+    "str_contains": {
+      "signature": "str_contains(string $haystack, string $needle): bool",
+      "description": "(PHP 8.0+) Performs a case-sensitive check indicating if needle is contained in haystack.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "haystack", "type": "string", "description": "The string to search in" },
+        { "name": "needle", "type": "string", "description": "The substring to search for" }
+      ],
+      "returns": "bool"
+    },
+    "str_starts_with": {
+      "signature": "str_starts_with(string $haystack, string $needle): bool",
+      "description": "(PHP 8.0+) Checks if a string starts with a given substring. Case-sensitive.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "haystack", "type": "string", "description": "The string to search in" },
+        { "name": "needle", "type": "string", "description": "The substring to search for at the start" }
+      ],
+      "returns": "bool"
+    },
+    "str_ends_with": {
+      "signature": "str_ends_with(string $haystack, string $needle): bool",
+      "description": "(PHP 8.0+) Checks if a string ends with a given substring. Case-sensitive.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "haystack", "type": "string", "description": "The string to search in" },
+        { "name": "needle", "type": "string", "description": "The substring to search for at the end" }
+      ],
+      "returns": "bool"
+    },
+    "strtolower": {
+      "signature": "strtolower(string $string): string",
+      "description": "Returns a string with all ASCII alphabetic characters converted to lowercase.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The input string" }
+      ],
+      "returns": "string"
+    },
+    "strtoupper": {
+      "signature": "strtoupper(string $string): string",
+      "description": "Returns a string with all ASCII alphabetic characters converted to uppercase.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The input string" }
+      ],
+      "returns": "string"
+    },
+    "trim": {
+      "signature": "trim(string $string, string $characters = \" \\n\\r\\t\\v\\0\"): string",
+      "description": "Strips whitespace (or other characters) from the beginning and end of a string.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The string that will be trimmed" },
+        { "name": "characters", "type": "string", "description": "Characters to strip" }
+      ],
+      "returns": "string"
+    },
+    "explode": {
+      "signature": "explode(string $separator, string $string, int $limit = PHP_INT_MAX): array",
+      "description": "Returns an array of strings, each of which is a substring of string formed by splitting on the separator.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "separator", "type": "string", "description": "The boundary string" },
+        { "name": "string", "type": "string", "description": "The input string" },
+        { "name": "limit", "type": "int", "description": "Maximum number of elements in the result" }
+      ],
+      "returns": "array"
+    },
+    "implode": {
+      "signature": "implode(string $separator, array $array): string",
+      "description": "Joins array elements with a glue string. join() is an alias.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "separator", "type": "string", "description": "The glue string placed between elements" },
+        { "name": "array", "type": "array", "description": "The array of strings to join" }
+      ],
+      "returns": "string"
+    },
+    "str_pad": {
+      "signature": "str_pad(string $string, int $length, string $pad_string = ' ', int $pad_type = STR_PAD_RIGHT): string",
+      "description": "Pads a string to a certain length with another string.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The input string" },
+        { "name": "length", "type": "int", "description": "Desired length of the final string" },
+        { "name": "pad_string", "type": "string", "description": "String to pad with" },
+        { "name": "pad_type", "type": "int", "description": "STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH" }
+      ],
+      "returns": "string"
+    },
+    "str_repeat": {
+      "signature": "str_repeat(string $string, int $times): string",
+      "description": "Returns a string repeated the specified number of times.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The string to be repeated" },
+        { "name": "times", "type": "int", "description": "Number of times to repeat" }
+      ],
+      "returns": "string"
+    },
+    "sprintf": {
+      "signature": "sprintf(string $format, mixed ...$values): string",
+      "description": "Returns a string produced according to the formatting string format.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "format", "type": "string", "description": "The format string with conversion specifiers" },
+        { "name": "values", "type": "mixed", "description": "Values to insert into format specifiers" }
+      ],
+      "returns": "string"
+    },
+    "htmlspecialchars": {
+      "signature": "htmlspecialchars(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE, ?string $encoding = null, bool $double_encode = true): string",
+      "description": "Converts special characters to HTML entities. Essential for XSS prevention.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The string being converted" },
+        { "name": "flags", "type": "int", "description": "Bitmask of ENT_* constants" },
+        { "name": "encoding", "type": "?string", "description": "Character encoding (default: ini get default_charset)" },
+        { "name": "double_encode", "type": "bool", "description": "Whether to encode existing HTML entities" }
+      ],
+      "returns": "string"
+    },
+    "urlencode": {
+      "signature": "urlencode(string $string): string",
+      "description": "URL-encodes a string, replacing special characters with percent-encoded values. Spaces become +.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The string to be encoded" }
+      ],
+      "returns": "string"
+    },
+    "base64_encode": {
+      "signature": "base64_encode(string $string): string",
+      "description": "Encodes data with MIME base64. Designed to make binary data survive transport through non-binary-safe channels.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "string", "type": "string", "description": "The data to encode" }
+      ],
+      "returns": "string"
+    },
+    "array_push": {
+      "signature": "array_push(array &$array, mixed ...$values): int",
+      "description": "Pushes one or more elements onto the end of an array. Equivalent to $array[] = $value for a single value.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array (passed by reference)" },
+        { "name": "values", "type": "mixed", "description": "The values to push" }
+      ],
+      "returns": "int"
+    },
+    "array_pop": {
+      "signature": "array_pop(array &$array): mixed",
+      "description": "Pops and returns the last element of the array, shortening the array by one element.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The array to get the value from" }
+      ],
+      "returns": "mixed"
+    },
+    "array_shift": {
+      "signature": "array_shift(array &$array): mixed",
+      "description": "Shifts the first value off the array and returns it. Numeric keys are re-indexed starting from zero.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" }
+      ],
+      "returns": "mixed"
+    },
+    "array_unshift": {
+      "signature": "array_unshift(array &$array, mixed ...$values): int",
+      "description": "Prepends one or more elements to the beginning of an array. All numerical keys are re-indexed.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "values", "type": "mixed", "description": "The values to prepend" }
+      ],
+      "returns": "int"
+    },
+    "array_merge": {
+      "signature": "array_merge(array ...$arrays): array",
+      "description": "Merges the elements of one or more arrays. Numeric keys are re-indexed; string keys are overwritten by later arrays.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "arrays", "type": "array", "description": "Arrays to merge" }
+      ],
+      "returns": "array"
+    },
+    "array_map": {
+      "signature": "array_map(?callable $callback, array $array, array ...$arrays): array",
+      "description": "Applies the callback to the elements of the given arrays and returns a new array containing the results.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "callback", "type": "?callable", "description": "Callback function to apply to each element" },
+        { "name": "array", "type": "array", "description": "Array to run through the callback" },
+        { "name": "arrays", "type": "array", "description": "Additional arrays for multi-array mapping" }
+      ],
+      "returns": "array"
+    },
+    "array_filter": {
+      "signature": "array_filter(array $array, ?callable $callback = null, int $mode = 0): array",
+      "description": "Filters elements of an array using a callback function. Keys are preserved.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The array to iterate over" },
+        { "name": "callback", "type": "?callable", "description": "The callback function; if null, removes falsy values" },
+        { "name": "mode", "type": "int", "description": "Flag determining callback arguments (ARRAY_FILTER_USE_KEY, ARRAY_FILTER_USE_BOTH)" }
+      ],
+      "returns": "array"
+    },
+    "array_reduce": {
+      "signature": "array_reduce(array $array, callable $callback, mixed $initial = null): mixed",
+      "description": "Iteratively reduces the array to a single value using a callback function.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "callback", "type": "callable", "description": "Function receiving (carry, item) and returning carry" },
+        { "name": "initial", "type": "mixed", "description": "Initial value for the carry" }
+      ],
+      "returns": "mixed"
+    },
+    "array_keys": {
+      "signature": "array_keys(array $array, mixed $filter_value = null, bool $strict = false): array",
+      "description": "Returns all the keys or a subset of the keys of an array.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "filter_value", "type": "mixed", "description": "If specified, only keys containing this value are returned" },
+        { "name": "strict", "type": "bool", "description": "Use strict comparison (===)" }
+      ],
+      "returns": "array"
+    },
+    "array_values": {
+      "signature": "array_values(array $array): array",
+      "description": "Returns all the values from the array and indexes the array numerically.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" }
+      ],
+      "returns": "array"
+    },
+    "array_unique": {
+      "signature": "array_unique(array $array, int $flags = SORT_STRING): array",
+      "description": "Removes duplicate values from an array. The first occurrence of each value is kept.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "flags", "type": "int", "description": "Sorting behavior flag" }
+      ],
+      "returns": "array"
+    },
+    "array_reverse": {
+      "signature": "array_reverse(array $array, bool $preserve_keys = false): array",
+      "description": "Returns an array with elements in reverse order.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "preserve_keys", "type": "bool", "description": "Whether to preserve numeric keys" }
+      ],
+      "returns": "array"
+    },
+    "array_slice": {
+      "signature": "array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array",
+      "description": "Extracts a slice of the array.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "offset", "type": "int", "description": "Start position" },
+        { "name": "length", "type": "?int", "description": "Number of elements to return" },
+        { "name": "preserve_keys", "type": "bool", "description": "Whether to preserve keys" }
+      ],
+      "returns": "array"
+    },
+    "array_splice": {
+      "signature": "array_splice(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array",
+      "description": "Removes a portion of the array and replaces it with something else. Returns the removed elements.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array (modified by reference)" },
+        { "name": "offset", "type": "int", "description": "Start position for removal" },
+        { "name": "length", "type": "?int", "description": "Number of elements to remove" },
+        { "name": "replacement", "type": "mixed", "description": "Elements to insert at the offset" }
+      ],
+      "returns": "array"
+    },
+    "array_search": {
+      "signature": "array_search(mixed $needle, array $haystack, bool $strict = false): int|string|false",
+      "description": "Searches the array for a given value and returns the first corresponding key if successful.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "needle", "type": "mixed", "description": "The searched value" },
+        { "name": "haystack", "type": "array", "description": "The array to search in" },
+        { "name": "strict", "type": "bool", "description": "Use strict type comparison" }
+      ],
+      "returns": "int|string|false"
+    },
+    "in_array": {
+      "signature": "in_array(mixed $needle, array $haystack, bool $strict = false): bool",
+      "description": "Checks if a value exists in an array.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "needle", "type": "mixed", "description": "The searched value" },
+        { "name": "haystack", "type": "array", "description": "The array to search" },
+        { "name": "strict", "type": "bool", "description": "Use strict comparison (===)" }
+      ],
+      "returns": "bool"
+    },
+    "count": {
+      "signature": "count(Countable|array $value, int $mode = COUNT_NORMAL): int",
+      "description": "Counts all elements in an array or a Countable object.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "value", "type": "Countable|array", "description": "The array or Countable object" },
+        { "name": "mode", "type": "int", "description": "COUNT_NORMAL or COUNT_RECURSIVE" }
+      ],
+      "returns": "int"
+    },
+    "sort": {
+      "signature": "sort(array &$array, int $flags = SORT_REGULAR): true",
+      "description": "Sorts an array in ascending order by value. Existing keys are discarded and the array is re-indexed.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "flags", "type": "int", "description": "Sorting type flags (SORT_REGULAR, SORT_NUMERIC, etc.)" }
+      ],
+      "returns": "true"
+    },
+    "usort": {
+      "signature": "usort(array &$array, callable $callback): true",
+      "description": "Sorts an array by values using a user-defined comparison function.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The input array" },
+        { "name": "callback", "type": "callable", "description": "Comparison function returning < 0, 0, or > 0" }
+      ],
+      "returns": "true"
+    },
+    "array_walk": {
+      "signature": "array_walk(array|object &$array, callable $callback, mixed $arg = null): true",
+      "description": "Applies a user-supplied function to every member of an array.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array|object", "description": "The input array" },
+        { "name": "callback", "type": "callable", "description": "Function receiving (&$value, $key, $arg)" },
+        { "name": "arg", "type": "mixed", "description": "Extra parameter passed to callback" }
+      ],
+      "returns": "true"
+    },
+    "array_key_exists": {
+      "signature": "array_key_exists(string|int $key, array $array): bool",
+      "description": "Returns true if the given key/index exists in the array. Unlike isset(), returns true even if value is null.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "key", "type": "string|int", "description": "Value to check" },
+        { "name": "array", "type": "array", "description": "Array with keys to check" }
+      ],
+      "returns": "bool"
+    },
+    "array_column": {
+      "signature": "array_column(array $array, int|string|null $column_key, int|string|null $index_key = null): array",
+      "description": "Returns the values from a single column of a multi-dimensional array.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "A multi-dimensional array or array of objects" },
+        { "name": "column_key", "type": "int|string|null", "description": "The column of values to return" },
+        { "name": "index_key", "type": "int|string|null", "description": "The column to use as index/keys" }
+      ],
+      "returns": "array"
+    },
+    "array_chunk": {
+      "signature": "array_chunk(array $array, int $length, bool $preserve_keys = false): array",
+      "description": "Splits an array into chunks of the given size.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The array to split" },
+        { "name": "length", "type": "int", "description": "The size of each chunk" },
+        { "name": "preserve_keys", "type": "bool", "description": "Whether to preserve keys" }
+      ],
+      "returns": "array"
+    },
+    "array_combine": {
+      "signature": "array_combine(array $keys, array $values): array",
+      "description": "Creates an array by using one array for keys and another for its values.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "keys", "type": "array", "description": "Array to be used as keys" },
+        { "name": "values", "type": "array", "description": "Array to be used as values" }
+      ],
+      "returns": "array"
+    },
+    "array_diff": {
+      "signature": "array_diff(array $array, array ...$arrays): array",
+      "description": "Computes the difference of arrays. Returns values in the first array that are not present in any of the other arrays.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The array to compare from" },
+        { "name": "arrays", "type": "array", "description": "Arrays to compare against" }
+      ],
+      "returns": "array"
+    },
+    "array_intersect": {
+      "signature": "array_intersect(array $array, array ...$arrays): array",
+      "description": "Computes the intersection of arrays. Returns values present in the first array that also exist in all other arrays.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "array", "type": "array", "description": "The array to compare from" },
+        { "name": "arrays", "type": "array", "description": "Arrays to compare against" }
+      ],
+      "returns": "array"
+    },
+    "array_fill": {
+      "signature": "array_fill(int $start_index, int $count, mixed $value): array",
+      "description": "Fills an array with the specified value, starting at the given index for a specified number of entries.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "start_index", "type": "int", "description": "The first index of the returned array" },
+        { "name": "count", "type": "int", "description": "Number of elements to insert" },
+        { "name": "value", "type": "mixed", "description": "Value to use for filling" }
+      ],
+      "returns": "array"
+    },
+    "compact": {
+      "signature": "compact(array|string $var_name, array|string ...$var_names): array",
+      "description": "Creates an array containing variables and their values from the current symbol table.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "var_name", "type": "array|string", "description": "Variable name or array of variable names" },
+        { "name": "var_names", "type": "array|string", "description": "Additional variable names" }
+      ],
+      "returns": "array"
+    },
+    "range": {
+      "signature": "range(string|int|float $start, string|int|float $end, int|float $step = 1): array",
+      "description": "Creates an array containing a range of elements from start to end.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "start", "type": "string|int|float", "description": "First value of the sequence" },
+        { "name": "end", "type": "string|int|float", "description": "Ending value of the sequence" },
+        { "name": "step", "type": "int|float", "description": "Increment between elements" }
+      ],
+      "returns": "array"
+    },
+    "json_encode": {
+      "signature": "json_encode(mixed $value, int $flags = 0, int $depth = 512): string|false",
+      "description": "Returns the JSON representation of a value.",
+      "type": "function",
+      "module": "json",
+      "parameters": [
+        { "name": "value", "type": "mixed", "description": "The value being encoded" },
+        { "name": "flags", "type": "int", "description": "Bitmask of JSON_* constants" },
+        { "name": "depth", "type": "int", "description": "Maximum depth; must be greater than zero" }
+      ],
+      "returns": "string|false"
+    },
+    "json_decode": {
+      "signature": "json_decode(string $json, ?bool $associative = null, int $depth = 512, int $flags = 0): mixed",
+      "description": "Decodes a JSON string. When associative is true, JSON objects are returned as associative arrays.",
+      "type": "function",
+      "module": "json",
+      "parameters": [
+        { "name": "json", "type": "string", "description": "The JSON string being decoded" },
+        { "name": "associative", "type": "?bool", "description": "true = arrays, false/null = objects" },
+        { "name": "depth", "type": "int", "description": "Maximum nesting depth" },
+        { "name": "flags", "type": "int", "description": "Bitmask of JSON_* constants" }
+      ],
+      "returns": "mixed"
+    },
+    "file_get_contents": {
+      "signature": "file_get_contents(string $filename, bool $use_include_path = false, ?resource $context = null, int $offset = 0, ?int $length = null): string|false",
+      "description": "Reads entire file into a string. Preferred way to read file contents. Supports HTTP/HTTPS URLs when allow_url_fopen is enabled.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "filename", "type": "string", "description": "Name of the file to read" },
+        { "name": "use_include_path", "type": "bool", "description": "Search in include_path" },
+        { "name": "context", "type": "?resource", "description": "Stream context resource" },
+        { "name": "offset", "type": "int", "description": "Offset where reading starts" },
+        { "name": "length", "type": "?int", "description": "Maximum bytes to read" }
+      ],
+      "returns": "string|false"
+    },
+    "file_put_contents": {
+      "signature": "file_put_contents(string $filename, mixed $data, int $flags = 0, ?resource $context = null): int|false",
+      "description": "Writes data to a file. Equivalent to fopen(), fwrite(), and fclose() successively. Use FILE_APPEND to append.",
+      "type": "function",
+      "module": "Core",
+      "parameters": [
+        { "name": "filename", "type": "string", "description": "Path to the file to write" },
+        { "name": "data", "type": "mixed", "description": "The data to write (string, array, or stream resource)" },
+        { "name": "flags", "type": "int", "description": "FILE_APPEND, LOCK_EX, or combination" },
+        { "name": "context", "type": "?resource", "description": "Stream context resource" }
+      ],
+      "returns": "int|false"
+    }
+  }
+}