[
  {
    "name": "Array",
    "static": true,
    "description": "Static array related prototypes and functions.",
    "method": [
      {
        "name": "clear",
        "description": "Clears an array by removing all elements.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "combine",
        "param": [
          {
            "name": "keys",
            "type": "object",
            "value": "[key, ...]"
          },
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[keys-unique-string-value: last-applicable-value, ...]"
          }
        ]
      },
      {
        "name": "complementByKeys",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-original-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "complementByValues",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: retained-original-value, ...]"
          }
        ]
      },
      {
        "name": "concat",
        "description": "Concatenates specific values to an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the original keys in the array, but implicitly generates a consecutive numeric key for each added value."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: original-value, ..., concatenated-value, ...]"
          }
        ]
      },
      {
        "name": "contains",
        "description": "Determines whether an array contains specific elements.",
        "annotation": [
          "This function returns true for an empty elements list (vacuous truth)."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "count",
        "description": "Counts the total number of elements within an array.",
        "annotation": [
          "This function is equivalent to the \"count\" operator on objects."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countDistinctValues",
        "description": "Counts the total number of distinct values within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countUsedValues",
        "description": "Counts the total number of occurrences for each value within an array.",
        "annotation": [
          "Values are interpreted as strings for the purpose of counting."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-string-value: count, ...]"
          }
        ]
      },
      {
        "name": "countValue",
        "description": "Counts the total number of occurrences of a specific value within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "createAssociative",
        "description": "Creates an associative array with uniformly initialized values.",
        "param": [
          {
            "name": "keys",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[keys-unique-string-value: init-value, ...]"
          }
        ]
      },
      {
        "name": "createIndex",
        "description": "Creates an indexed array of a specific length with uniformly initialized values.",
        "annotation": [
          "This function implicitly generates a consecutive numeric key for each value."
        ],
        "param": [
          {
            "name": "length",
            "type": "int"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[init-value, ...]"
          }
        ]
      },
      {
        "name": "createRange",
        "description": "Creates an indexed array with values of a specific numeric range.",
        "annotation": [
          "This function implicitly generates a consecutive numeric key for each value."
        ],
        "param": [
          {
            "name": "from",
            "type": "number"
          },
          {
            "name": "to",
            "type": "number"
          },
          {
            "name": "step",
            "type": "number",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[range-value, ...]"
          }
        ]
      },
      {
        "name": "equals",
        "description": "Determines whether two arrays are equal, not considering the order of elements, meaning they have the same elements, but not necessarily in the same order.",
        "param": [
          {
            "name": "array1",
            "type": "object"
          },
          {
            "name": "array2",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "equalsInOrder",
        "description": "Determines whether two arrays are equal, also considering the order of elements, meaning they have the same elements in the same order.",
        "param": [
          {
            "name": "array1",
            "type": "object"
          },
          {
            "name": "array2",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "every",
        "annotation": [
          "This function returns true for an empty array (vacuous truth)."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "filter",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-key: retained-value, ...]"
          }
        ]
      },
      {
        "name": "findKey",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if not found"
          }
        ]
      },
      {
        "name": "findValue",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if not found"
          }
        ]
      },
      {
        "name": "firstKey",
        "description": "Returns the key of the first element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "firstValue",
        "description": "Returns the value of the first element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "flip",
        "description": "Flips the elements of an array by exchanging keys for values.",
        "annotation": [
          "A key may specify the column of a multidimensional array to flip by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is skipped.",
          "Values are interpreted as strings for the purpose of flipping. If a value has several occurrences within the array, only the key of the last occurrence of that particular value is retained.",
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-string-value: last-applicable-key, ...]"
          }
        ]
      },
      {
        "name": "forEach",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ]
      },
      {
        "name": "fromCSV",
        "annotation": [
          "This function is complementary to \"toCSV\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[value, ...], ...]"
          }
        ]
      },
      {
        "name": "getUniformType",
        "description": "Gets the uniformly determined type of all values in an array.",
        "annotation": [
          "This function returns \"number\" for mixed int and float types, \"scalar\" for mixed scalar types, \"complex\" for mixed complex types, or \"mixed\" if types vary accross both scalar and complex types."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "hasAllKeys",
        "description": "Determines whether an array has all of the specific keys.",
        "annotation": [
          "This function returns true for an empty keys list (vacuous truth)."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "keys",
            "type": "object",
            "value": "[key, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasAllValues",
        "description": "Determines whether an array has all of the specific values.",
        "annotation": [
          "This function returns true for an empty values list (vacuous truth)."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasAnyKeys",
        "description": "Determines whether an array has any (at least one) of the specific keys.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "keys",
            "type": "object",
            "value": "[key, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasAnyValues",
        "description": "Determines whether an array has any (at least one) of the specific values.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasKey",
        "description": "Determines whether an array has a specific key.",
        "annotation": [
          "This function is equivalent to the \"in\" operator on objects."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "string",
            "default": "\"0\""
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasSameKeys",
        "description": "Determines whether two arrays have the same keys.",
        "param": [
          {
            "name": "array1",
            "type": "object"
          },
          {
            "name": "array2",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasSameKeysInOrder",
        "description": "Determines whether two arrays have the same keys, also considering the order of keys, meaning they have the same keys in the same order.",
        "param": [
          {
            "name": "array1",
            "type": "object"
          },
          {
            "name": "array2",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasSameValues",
        "description": "Determines whether two arrays have the same values.",
        "param": [
          {
            "name": "array1",
            "type": "object"
          },
          {
            "name": "array2",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasValue",
        "description": "Determines whether an array has a specific value.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "head",
        "description": "Returns the head of an array, meaning only the first element.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[first-key: first-value]"
          }
        ]
      },
      {
        "name": "insert",
        "description": "Inserts specific values into an array at a specific offset.",
        "annotation": [
          "If the offset is negative, it inserts at that many elements from the end of the array.",
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all numeric keys in the array and implicitly generates a consecutive numeric key for each inserted value."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[(non-numeric-original-key: original-value) / original-value-if-numeric-key, ..., inserted-value, ..., (non-numeric-original-key: original-value) / original-value-if-numeric-key, ...]"
          }
        ]
      },
      {
        "name": "intersectByKeys",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-original-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "intersectByValues",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: retained-original-value, ...]"
          }
        ]
      },
      {
        "name": "isEmpty",
        "description": "Determines whether an array is empty, meaning it does not contain any elements.",
        "annotation": [
          "This function is equivalent to the \"empty\" operator on objects."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isIndexed",
        "description": "Determines whether an array is indexed, meaning it only contains consecutive numeric keys from zero onwards.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isMultidimensional",
        "description": "Determines whether an array is multidimensional, meaning it contains object values.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "joinKeys",
        "description": "Joins the keys of an array to form a string representation with each key separated by a specific delimiter.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "delimiter",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "joinNonEmptyValues",
        "description": "Joins the values of an array to form a string representation with each value separated by a specific delimiter, whereas empty string values are ignored.",
        "annotation": [
          "A key may specify the column of a multidimensional array to join by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is skipped.",
          "Values are interpreted as strings for the purpose of joining."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "delimiter",
            "type": "string"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "joinValues",
        "description": "Joins the values of an array to form a string representation with each value separated by a specific delimiter.",
        "annotation": [
          "A key may specify the column of a multidimensional array to join by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is skipped.",
          "Values are interpreted as strings for the purpose of joining."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "delimiter",
            "type": "string"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "keyAt",
        "description": "Returns the key at a specific offset within an array.",
        "annotation": [
          "If the offset is negative, it positions at that many elements from the end of the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if the offset is out of range"
          }
        ]
      },
      {
        "name": "keyOf",
        "description": "Returns the key of the first occurrence of a specific value within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if the value is not found"
          }
        ]
      },
      {
        "name": "lastKey",
        "description": "Returns the key of the last element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "lastKeyOf",
        "description": "Returns the key of the last occurrence of a specific value within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the value is not found"
          }
        ]
      },
      {
        "name": "lastValue",
        "description": "Returns the value of the last element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "linearize",
        "description": "Linearizes the elements of a multidimensional array by a specific key.",
        "annotation": [
          "If the key does not exist within the inner array, the corresponding element of the outer array is discarded.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "string",
            "default": "\"0\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[outer-key: inner-value-by-key, ...]"
          }
        ]
      },
      {
        "name": "listKeys",
        "description": "Lists all keys of an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key, ...]"
          }
        ]
      },
      {
        "name": "listValues",
        "description": "Lists all values of an array.",
        "annotation": [
          "A key may specify the column of a multidimensional array to list by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is skipped."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-value, ...]"
          }
        ]
      },
      {
        "name": "map",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: mapped-value, ...]"
          }
        ]
      },
      {
        "name": "merge",
        "description": "Merges an array with specific elements, whereas duplicate non-numeric keys are overwritten while elements with numeric keys are appended.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the original keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: (elements-value / original-value), ..., (supplemental-non-numeric-elements-key: elements-value) / elements-value-if-numeric-key, ...]"
          }
        ]
      },
      {
        "name": "pad",
        "description": "Pads an array to a specific length by repeatedly filling it with a specific padding value.",
        "annotation": [
          "If the length is positive, the array is padded right-sidedly at its end, if it is negative, the array is padded left-sidedly at its beginning.",
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all numeric keys in the array and implicitly generates a consecutive numeric key for each added value."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "length",
            "type": "int"
          },
          {
            "name": "padding",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[(non-numeric-original-key: original-value) / original-value-if-numeric-key, ..., padding-value, ...]"
          }
        ]
      },
      {
        "name": "partition",
        "description": "Partitions an array into isolated chunks of a specific length.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "length",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[original-key: original-value, ...], ...]"
          }
        ]
      },
      {
        "name": "pop",
        "description": "Pops an element off the end of an array and returns its value.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "push",
        "description": "Pushes a specific value onto the end of an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the original keys in the array, but implicitly generate a consecutive numeric key for the added value. It is equivalent to the \"[]\" operator."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: original-value, ..., added-value]"
          }
        ]
      },
      {
        "name": "randomKey",
        "description": "Returns the key of a random element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "int",
            "description": "if integer key"
          },
          {
            "type": "string",
            "description": "if string key"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "randomValue",
        "description": "Returns the value of a random element within an array.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "reduce",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "initial",
            "type": "mixed"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "reindex",
        "description": "Re-indexes all elements of an array with consecutive numeric keys.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "initial",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-value, ...]"
          }
        ]
      },
      {
        "name": "remove",
        "description": "Removes specific elements from an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-key: retained-value, ...]"
          }
        ]
      },
      {
        "name": "removeKey",
        "description": "Remove the element with a specific key from an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "string",
            "default": "\"0\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "removeKeys",
        "description": "Removes elements with specific keys from an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "keys",
            "type": "object",
            "value": "[key, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "removeValue",
        "description": "Removes elements with a specific value from an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: retained-value, ...]"
          }
        ]
      },
      {
        "name": "removeValues",
        "description": "Removes elements with specific values from an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: retained-value, ...]"
          }
        ]
      },
      {
        "name": "repeat",
        "description": "Repeatedly concatenates specific values to themselves and returns the aligned end-to-end array.",
        "annotation": [
          "This function implicitly generates a consecutive numeric key for each value."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "count",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[first-value, ..., last-value, first-value, ..., last-value, ...]"
          }
        ]
      },
      {
        "name": "replace",
        "description": "Replaces specific elements of an array based on common keys.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: (elements-value / original-value), ..., supplemental-elements-key: elements-value, ...]"
          }
        ]
      },
      {
        "name": "reverse",
        "description": "Reverse the order of elements within an array.",
        "annotation": [
          "This function is its own inverse. It is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[last-key: last-value, ..., first-key: first-value]"
          }
        ]
      },
      {
        "name": "shift",
        "description": "Shifts an element off the beginning of an array and returns its value.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all numeric keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the array is empty"
          }
        ]
      },
      {
        "name": "shuffle",
        "description": "Suffles an array by randomizing the order of elements.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "slice",
        "description": "Slices an array by creating a shallow copy of a specific portion.",
        "annotation": [
          "If the offset is negative, it starts that many elements from the end of the array. If the length is null, every element from the offset until the end of the array is returned, if it is negative, it stops that many elements from the end of the array.",
          "This function preserves the keys in the array. It is equivalent to the \"[..., ...]\" operator on objects."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[retained-key: retained-value, ...]"
          }
        ]
      },
      {
        "name": "some",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "sortAscByKeys",
        "description": "Sorts an array by keys in ascending lexicographic or numeric order.",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "sortAscByValues",
        "description": "Sorts an array by values in ascending lexicographic or numeric order.",
        "annotation": [
          "A key may specify the column of a multidimensional array to sort by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is interpreted as null for the purpose of sorting.",
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "sortByKeys",
        "description": "Sorts an array by keys in a particular order determined by a specific comparison callback function.",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "sortByValues",
        "description": "Sorts an array by values in a particular order determined by a specific comparison callback function.",
        "annotation": [
          "A key may specify the column of a multidimensional array to sort by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is interpreted as null for the purpose of sorting.",
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "sortDescByKeys",
        "description": "Sorts an array by keys in descending lexicographic or numeric order.",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "sortDescByValues",
        "description": "Sorts an array by values in descending lexicographic or numeric order.",
        "annotation": [
          "A key may specify the column of a multidimensional array to sort by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is interpreted as null for the purpose of sorting.",
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "sortMultidimensional",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "callbacks",
            "type": "object",
            "value": "[key: callback, ...]"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "sortNaturalAscByKeys",
        "description": "Sorts an array by keys in ascending natural and case-insensitive order (US-ASCII only).",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "sortNaturalAscByValues",
        "description": "Sorts an array by values in ascending natural and case-insensitive order (US-ASCII only).",
        "annotation": [
          "A key may specify the column of a multidimensional array to sort by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is interpreted as null for the purpose of sorting.",
          "The sorting is guaranteed to be stable. Complex values are interpreted as strings for the purpose of sorting.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "sortNaturalDescByKeys",
        "description": "Sorts an array by keys in descending natural and case-insensitive order (US-ASCII only).",
        "annotation": [
          "The sorting is guaranteed to be stable.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[reordered-key: original-value, ...]"
          }
        ]
      },
      {
        "name": "sortNaturalDescByValues",
        "description": "Sorts an array by values in descending natural and case-insensitive order (US-ASCII only).",
        "annotation": [
          "A key may specify the column of a multidimensional array to sort by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is interpreted as null for the purpose of sorting.",
          "The sorting is guaranteed to be stable. Complex values are interpreted as strings for the purpose of sorting.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: reordered-value, ...]"
          }
        ]
      },
      {
        "name": "splice",
        "description": "Extracts a specific portion of an array and replaces it with specific replacement values.",
        "annotation": [
          "If the offset is negative, it starts that many elements from the end of the array. If the length is null, every element from the offset until the end of the array is extracted, if it is negative, it stops that many elements from the end of the array.",
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all numeric keys in the original array and implicitly generates a consecutive numeric key for each replaced value, but preserves the keys in the extracted array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          },
          {
            "name": "replacement",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[extracted-key: extracted-value, ...]"
          }
        ]
      },
      {
        "name": "tail",
        "description": "Creates a shallow copy of the tail of an array, meaning all elements except the first.",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[tail-key: tail-value, ...]"
          }
        ]
      },
      {
        "name": "toCSV",
        "annotation": [
          "This function is complementary to \"fromCSV\"."
        ],
        "param": [
          {
            "name": "array",
            "type": "object",
            "value": "[[value, ...], ...]"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          },
          {
            "name": "enclosed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toLowerKeys",
        "description": "Converts the keys of an array to lower case (UTF-8).",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-lower-string-key: last-applicable-value, ...]"
          }
        ]
      },
      {
        "name": "toLowerKeys",
        "description": "Converts the keys of an array to lower case (US-ASCII only).",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-lower-string-key: last-applicable-value, ...]"
          }
        ]
      },
      {
        "name": "toUpperKeys",
        "description": "Converts the keys of an array to upper case (UTF-8).",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-upper-string-key: last-applicable-value, ...]"
          }
        ]
      },
      {
        "name": "toUpperKeys",
        "description": "Converts the keys of an array to upper case (US-ASCII only).",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-upper-string-key: last-applicable-value, ...]"
          }
        ]
      },
      {
        "name": "unionByKeys",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: original-value, ..., supplemental-elements-key: elements-value]"
          }
        ]
      },
      {
        "name": "unionByValues",
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "arrays",
            "type": "variadic",
            "value": "[key: value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[original-key: (supplemental-elements-value / original-value), ..., (non-numeric-elements-key: supplemental-elements-value) / supplemental-elements-value-if-numeric-key, ...]"
          }
        ]
      },
      {
        "name": "unique",
        "description": "Uniquifies an array by discarding duplicate values, retaining only the first occurrence of each value.",
        "annotation": [
          "A key may specify the column of a multidimensional array to distinguish by. If the key is null, the array is treated as an unidimensional list. If a key is specified, and it does not exist within the inner array, the corresponding element of the outer array is discarded.",
          "This function is destructive, in the sense that it modifies the array in-place. It preserves the keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "?string",
            "default": "unidimensional"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[first-applicable-key: unique-value, ...]"
          }
        ]
      },
      {
        "name": "unshift",
        "description": "Prepends a specific value to the beginning of an array.",
        "annotation": [
          "This function is destructive, in the sense that it modifies the array in-place. It re-indexes all numeric keys in the array."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[added-value, (non-numeric-original-key: original-value) / original-value-if-numeric-key, ...]"
          }
        ]
      },
      {
        "name": "valueAt",
        "description": "Returns the value at a specific key within an array.",
        "annotation": [
          "This function is equivalent to the \"[...]\" operator on objects."
        ],
        "param": [
          {
            "name": "array",
            "type": "object"
          },
          {
            "name": "key",
            "type": "string",
            "default": "\"0\""
          }
        ],
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if the key is not found"
          }
        ]
      }
    ]
  },
  {
    "name": "Array.Iterator",
    "static": false,
    "extend": "Base",
    "description": "Array iterator prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "array",
            "type": "object"
          }
        ]
      },
      {
        "name": "hasMore",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "next",
        "return": [
          {
            "type": "object",
            "value": "[key: value]"
          },
          {
            "type": "null",
            "description": "if there are no more elements"
          }
        ]
      },
      {
        "name": "reset",
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "Array.ReverseIterator",
    "static": false,
    "extend": "Array.Iterator",
    "description": "Array reverse iterator prototype."
  },
  {
    "name": "Base",
    "static": false,
    "description": "Base prototype.",
    "method": [
      {
        "name": "construct",
        "description": "Dummy fallback constructor function for ease of constructor chaining."
      },
      {
        "name": "callMethod",
        "description": "Calls a function with variadic arguments, bound as a method to this object.",
        "param": [
          {
            "name": "function",
            "type": "function"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "clone",
        "description": "Clones this object by creating a shallow copy.",
        "annotation": [
          "This function is equivalent to the \"clone\" operator on this object."
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "countSlots",
        "description": "Counts the total number of slots within this object.",
        "annotation": [
          "This function is equivalent to the \"count\" operator on this object."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getInternalID",
        "description": "Gets the unique internal identification number of this object.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "isInstanceOf",
        "description": "Determines whether this object is an instance of a specific prototype.",
        "annotation": [
          "This function is equivalent to the \"is\" operator on this object."
        ],
        "param": [
          {
            "name": "prototype",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listPrototypes",
        "description": "Lists all prototypes of this object.",
        "return": [
          {
            "type": "object",
            "value": "[prototype, ...]"
          }
        ]
      },
      {
        "name": "listSlotNames",
        "description": "Lists all slot names of this object.",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listSlots",
        "description": "Lists all slots of this object.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "toJSON",
        "description": "Returns the JavaScript Object Notation (JSON) representation of this object according to RFC 4627.",
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "Console",
    "static": true,
    "description": "Static console related functions.",
    "const": [
      {
        "name": "CREATOR",
        "type": "string",
        "description": "Zymba creator"
      },
      {
        "name": "VERSION",
        "type": "int",
        "description": "Zymba version number"
      }
    ],
    "method": [
      {
        "name": "clear",
        "description": "Clears the console by removing all messages."
      },
      {
        "name": "countMessages",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "disableAssertions",
        "description": "Disables assertions.",
        "annotation": [
          "This function is complementary to \"enableAssertions\"."
        ]
      },
      {
        "name": "enableAssertions",
        "description": "Enables assertions.",
        "annotation": [
          "This function is complementary to \"disableAssertions\"."
        ]
      },
      {
        "name": "getSummary",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "listMessages",
        "return": [
          {
            "type": "object",
            "value": "[message, ...]"
          }
        ]
      },
      {
        "name": "log",
        "param": [
          {
            "name": "messages",
            "type": "variadic"
          }
        ]
      }
    ]
  },
  {
    "name": "Crypt",
    "static": true,
    "description": "Static cryptographic functions.",
    "method": [
      {
        "name": "convertPublicKeyRSAToPEM",
        "description": "Converts a raw RSA exponent and modulus to a public key in PEM format.",
        "param": [
          {
            "name": "exponent",
            "type": "string"
          },
          {
            "name": "modulus",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createIV",
        "description": "Creates a suitable initialization vector for a specific cipher from a random source.",
        "param": [
          {
            "name": "cipher",
            "type": "string",
            "default": "\"aes-192-ecb\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createJWT",
        "description": "Creates a JSON Web Token (JWT) according to RFC 7519.",
        "annotation": [
          "Only JWTs based on JSON Web Signature (JWS) according to RFC 7515 are supported."
        ],
        "param": [
          {
            "name": "claims",
            "type": "object",
            "value": "[name: value]"
          },
          {
            "name": "key",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"HS256\""
          },
          {
            "name": "header",
            "type": "object",
            "value": "[name: value]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createNonce",
        "description": "Creates a nonce of a specific size in number of bytes from a random source in its hexadecimal string representation.",
        "param": [
          {
            "name": "size",
            "type": "int",
            "default": "20"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createNonceRaw",
        "description": "Creates a nonce of a specific size in number of bytes from a random source as raw binary data.",
        "param": [
          {
            "name": "size",
            "type": "int",
            "default": "20"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createPassword",
        "description": "Creates a secure password of a specific length in number of characters from a random source.",
        "annotation": [
          "The possible characters of the password are \"abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789\"."
        ],
        "param": [
          {
            "name": "length",
            "type": "int",
            "default": "10"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createTimeOrderedUUID",
        "description": "Creates a version 7 universally unique identifier (UUID) from the current timestamp and a random source according to RFC 4122.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createUUID",
        "description": "Creates a version 4 universally unique identifier (UUID) from a random source according to RFC 4122.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "decrypt",
        "description": "Decryptes a string with a specific key.",
        "annotation": [
          "This function is complementary to \"encrypt\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "key",
            "type": "string"
          },
          {
            "name": "cipher",
            "type": "string",
            "default": "\"aes-192-ecb\""
          },
          {
            "name": "iv",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if decryption failed"
          }
        ]
      },
      {
        "name": "encrypt",
        "description": "Encryptes a string with a specific key.",
        "annotation": [
          "This function is complementary to \"decrypt\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "key",
            "type": "string"
          },
          {
            "name": "cipher",
            "type": "string",
            "default": "\"aes-192-ecb\""
          },
          {
            "name": "iv",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "equalsTimeConstant",
        "description": "Determines whether two strings are equal based on time-constant string comparison that guards against timing attacks.",
        "param": [
          {
            "name": "secret",
            "type": "string"
          },
          {
            "name": "input",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hash",
        "description": "Generates the hash of a string in its hexadecimal string representation using a specific algorithm.",
        "annotation": [
          "A key may specify the shared secret key for generating the HMAC variant of the message digest according to RFC 2104."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "key",
            "type": "?string",
            "default": "non-HMAC"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hashFile",
        "description": "Generates the hash of the content of an existing file in its hexadecimal string representation using a specific algorithm.",
        "annotation": [
          "A key may specify the shared secret key for generating the HMAC variant of the message digest according to RFC 2104."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "key",
            "type": "?string",
            "default": "non-HMAC"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hashFileRaw",
        "description": "Generates the hash of the content of an existing file as raw binary data using a specific algorithm.",
        "annotation": [
          "A key may specify the shared secret key for generating the HMAC variant of the message digest according to RFC 2104."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "key",
            "type": "?string",
            "default": "non-HMAC"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hashPassword",
        "description": "Generates a password hash in the Modular Crypt Format (MCF) using the bcrypt algorithm.",
        "param": [
          {
            "name": "password",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hashRaw",
        "description": "Generates the hash of a string as raw binary data using a specific algorithm.",
        "annotation": [
          "A key may specify the shared secret key for generating the HMAC variant of the message digest according to RFC 2104."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "key",
            "type": "?string",
            "default": "non-HMAC"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "listCiphers",
        "description": "Lists all available ciphers.",
        "return": [
          {
            "type": "object",
            "value": "[cipher, ...]"
          }
        ]
      },
      {
        "name": "listHashAlgorithms",
        "description": "Lists all available hash algorithms.",
        "return": [
          {
            "type": "object",
            "value": "[algorithm, ...]"
          }
        ]
      },
      {
        "name": "pbkdf2",
        "description": "Generatesa a PBKDF2 key derived from a password along with a salt in its hexadecimal string representation using a specific algorithm according to RFC 2898.",
        "param": [
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "salt",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "iterations",
            "type": "int",
            "default": "10000"
          },
          {
            "name": "length",
            "type": "int",
            "default": "full key length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "pbkdf2Raw",
        "description": "Generates a PBKDF2 key derived from a password along with a salt as raw binary data using a specific algorithm according to RFC 2898.",
        "param": [
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "salt",
            "type": "string"
          },
          {
            "name": "algorithm",
            "type": "string",
            "default": "\"sha1\""
          },
          {
            "name": "iterations",
            "type": "int",
            "default": "10000"
          },
          {
            "name": "length",
            "type": "int",
            "default": "full key length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "verifyJWT",
        "description": "Verify a JSON Web Token (JWT) against a specific key according to RFC 7519 and returns its header parameters and claims.",
        "annotation": [
          "Only JWTs based on JSON Web Signature (JWS) according to RFC 7515 are supported.",
          "This function will not verify the type header parameter (\"typ\"), nor the expiration time claim (\"exp\")."
        ],
        "param": [
          {
            "name": "jwt",
            "type": "string"
          },
          {
            "name": "key",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[\"header\": [name: value, ...], \"claims\": [name: value, ...]]"
          },
          {
            "type": "null",
            "description": "if validation failed"
          }
        ]
      },
      {
        "name": "verifyPassword",
        "description": "Verify a password against a specific password hash in the Modular Crypt Format (MCF).",
        "param": [
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "hash",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      }
    ]
  },
  {
    "name": "DNS",
    "static": true,
    "description": "Static DNS related functions.",
    "method": [
      {
        "name": "exists",
        "description": "Determines whether a DNS record of a specific type exists for a host (domain name or IP address).",
        "param": [
          {
            "name": "host",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string",
            "default": "\"any\""
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidDomain",
        "description": "Determines whether a domain name is valid.",
        "param": [
          {
            "name": "domain",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidHost",
        "description": "Determines whether a host (domain name or IP address) is valid.",
        "param": [
          {
            "name": "host",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidIP",
        "description": "Determines whether an IP address is valid.",
        "param": [
          {
            "name": "ip",
            "type": "string",
            "default": "\"0.0.0.0\""
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "lookup",
        "description": "Resolves a domain name and returns its IP address.",
        "param": [
          {
            "name": "domain",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the domain name cannot be resolved"
          }
        ]
      },
      {
        "name": "resolve",
        "description": "Resolves a domain name into the DNS records of a specific type.",
        "param": [
          {
            "name": "domain",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string",
            "default": "\"any\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[\"host\": ..., \"class\": ..., \"type\": ..., \"ttl\": ...], ...]"
          },
          {
            "type": "null",
            "description": "if the domain name cannot be resolved"
          }
        ]
      },
      {
        "name": "reverse",
        "description": "Reverse resolves an IP address and returns its domain name.",
        "param": [
          {
            "name": "ip",
            "type": "string",
            "default": "\"0.0.0.0\""
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the IP address cannot be resolved"
          }
        ]
      }
    ]
  },
  {
    "name": "Date",
    "static": true,
    "description": "Static date and time related constants and functions.",
    "const": [
      {
        "name": "FORMAT_ISO8601",
        "type": "string",
        "description": "Date and time format according to ISO 8601 (\"Y-m-d\\TH:i:sP\")"
      },
      {
        "name": "FORMAT_ISO9075",
        "type": "string",
        "description": "Date and time format according to ISO 9075 (\"Y-m-d H:i:s\")"
      },
      {
        "name": "FORMAT_RFC1036",
        "type": "string",
        "description": "Date and time format according to RFC 1036 (\"D, d M y H:i:s O\")"
      },
      {
        "name": "FORMAT_RFC1123",
        "type": "string",
        "description": "Date and time format according to RFC 1123 (\"D, d M Y H:i:s O\")"
      },
      {
        "name": "FORMAT_RFC2822",
        "type": "string",
        "description": "Date and time format according to RFC 2822 (\"D, d M Y H:i:s O\")"
      },
      {
        "name": "FORMAT_RFC3339",
        "type": "string",
        "description": "Date and time format according to RFC 3339 (\"Y-m-d\\TH:i:sP\")"
      },
      {
        "name": "FORMAT_RFC822",
        "type": "string",
        "description": "Date and time format according to RFC 822 (\"D, d M y H:i:s O\")"
      },
      {
        "name": "FORMAT_RFC850",
        "type": "string",
        "description": "Date and time format according to RFC 850 (\"l, d-M-y H:i:s T\")"
      },
      {
        "name": "JUDGMENTDAY",
        "type": "int",
        "description": "Easter egg timestamp for the date on which Skynet becomes self-aware (1997-08-29 02:14:00 EST / 07:14:00 UTC)"
      }
    ],
    "method": [
      {
        "name": "create",
        "description": "Creates the timestamp of a Gregorian date formed by its components.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "day",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "month",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "year",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "hour",
            "type": "int"
          },
          {
            "name": "minute",
            "type": "int"
          },
          {
            "name": "second",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "createUTC",
        "description": "Creates the timestamp of a Gregorian date formed by its components using UTC instead of local time.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "day",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "month",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "year",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "hour",
            "type": "int"
          },
          {
            "name": "minute",
            "type": "int"
          },
          {
            "name": "second",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "format",
        "description": "Returns the formatted representation of a date according to a specific PHP-compatible format.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "format",
            "type": "string",
            "default": "\"c\""
          },
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "formatUTC",
        "description": "Returns the formatted representation of a date according to a specific PHP-compatible format using UTC instead of local time.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "format",
            "type": "string",
            "default": "\"c\""
          },
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDay",
        "description": "Gets the day of the month (1-31) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getDayOfWeek",
        "description": "Gets the day of the week (0-6) of a date.",
        "annotation": [
          "The week starts on Sunday.",
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getDayOfWeekISO8601",
        "description": "Gets the day of the week (1-7) of a date according to ISO 8601.",
        "annotation": [
          "The week starts on Monday.",
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getDayOfYear",
        "description": "Gets the day of the year (0-365) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getDaysInMonth",
        "description": "Gets the number of days in the month (28-31) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getHour",
        "description": "Gets the hour (0-23) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getMinute",
        "description": "Gets the minute (0-59) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getMonth",
        "description": "Gets the month (1-12) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getSecond",
        "description": "Gets the second (0-59) of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getTimezone",
        "description": "Gets the current time zone name as defined by the IANA Time Zone Database.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getTimezoneAbbreviation",
        "description": "Gets the current time zone abbreviation.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getTimezoneOffset",
        "description": "Gets the current time zone offset in number of seconds from UTC.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getWeekISO8601",
        "description": "Gets the week number in the year of a date according to ISO 8601.",
        "annotation": [
          "The week starts on Monday.",
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getYear",
        "description": "Gets the 4-digit year of a date.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getYearISO8601",
        "description": "Gets the 4-digit year of a date according to ISO 8601.",
        "annotation": [
          "The year is determined by the week number of the date.",
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "inDST",
        "description": "Determines whether a date is in daylight saving time.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isLeapYear",
        "description": "Determines whether the year of a date is a leap year.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isMidnight",
        "description": "Determines whether a date is midnight of the day.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValid",
        "description": "Determines whether a Gregorian date formed by specific components is valid.",
        "annotation": [
          "Leap years are taken into consideration."
        ],
        "param": [
          {
            "name": "day",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "month",
            "type": "?int",
            "default": "now"
          },
          {
            "name": "year",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listTimezones",
        "description": "List all available time zones.",
        "return": [
          {
            "type": "object",
            "value": "[timezone, ...]"
          }
        ]
      },
      {
        "name": "now",
        "description": "Returns the timestamp for the current date and time.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "nowExact",
        "description": "Returns the exact timestamp for the current date and time including microseconds in the fractional part.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "parse",
        "description": "Parses a textual representation of date and time and returns the corresponding timestamp.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the representation is invalid"
          }
        ]
      },
      {
        "name": "today",
        "description": "Returns the timestamp for today at midnight.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "truncateDay",
        "description": "Truncates a date to midnight of the day.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "truncateMonth",
        "description": "Truncates a date to the first day of the month.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "truncateYear",
        "description": "Truncates a date to the first day of the year.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "Date.TimezoneContext",
    "static": false,
    "extend": "Base",
    "description": "Timezone context prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "timezone",
            "type": "string",
            "default": "\"UTC\""
          }
        ]
      },
      {
        "name": "enter"
      },
      {
        "name": "exit"
      }
    ]
  },
  {
    "name": "Exception",
    "static": false,
    "extend": "Base",
    "description": "Exception prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "message",
            "type": "string"
          }
        ]
      },
      {
        "name": "countTraces",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getInitialTrace",
        "return": [
          {
            "type": "object",
            "value": "[\"filename\": ..., \"line\": ..., \"site\": ..., \"function\": ..., \"params\": ...]"
          },
          {
            "type": "null",
            "description": "if there is no initial trace"
          }
        ]
      },
      {
        "name": "getInternalState",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "type": "null",
            "description": "if there is no internal state"
          }
        ]
      },
      {
        "name": "getMessage",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getSummary",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getTracesAsString",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "listTraces",
        "return": [
          {
            "type": "object",
            "value": "[[\"filename\": ..., \"line\": ..., \"site\": ..., \"function\": ..., \"params\": ...], ...]"
          }
        ]
      },
      {
        "name": "toString",
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "FTP",
    "static": true,
    "description": "Static FTP related prototypes."
  },
  {
    "name": "FTP.Client",
    "static": false,
    "extend": "Base",
    "description": "FTP client prototype.",
    "method": [
      {
        "name": "construct",
        "description": "Opens a FTP connection to a specific server and attempts login.",
        "param": [
          {
            "name": "server",
            "type": "string"
          },
          {
            "name": "username",
            "type": "string",
            "default": "\"anonymous\""
          },
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ]
      },
      {
        "name": "append",
        "description": "Appends an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "close",
        "description": "Closes this client and frees its associated resources."
      },
      {
        "name": "countDirectories",
        "description": "Counts the total number of subdirectories in an existing directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countFiles",
        "description": "Counts the total number of files in an existing directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "createDirectory",
        "description": "Creates a directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "delete",
        "description": "Deletes an existing file.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "disablePassiveMode",
        "description": "Disables passive mode for this client.",
        "annotation": [
          "This function is complementary to \"enablePassiveMode\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "download",
        "description": "Downloads an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "echo",
        "description": "Outputs the content of an existing file.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "enablePassiveMode",
        "description": "Enables passive mode for this client.",
        "annotation": [
          "This function is complementary to \"disablePassiveMode\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "execute",
        "description": "Executes a FTP command and returns its output.",
        "param": [
          {
            "name": "command",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[line, ...]"
          },
          {
            "type": "null",
            "description": "if command failed"
          }
        ]
      },
      {
        "name": "exists",
        "description": "Determines whether a path exists.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this client and frees its associated resources for the purpose of contextualization."
      },
      {
        "name": "getLastModified",
        "description": "Gets the timestamp for the last modification date and time of an existing file.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if unavailable or path is a directory"
          }
        ]
      },
      {
        "name": "getSize",
        "description": "Gets the size of an existing file in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if unavailable or path is a directory"
          }
        ]
      },
      {
        "name": "getWorkingDirectory",
        "description": "Gets the path of the current working directory.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isConnected",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isDirectory",
        "description": "Determines whether a path exists and refers to a directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listDirectories",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[filename, ...]"
          }
        ]
      },
      {
        "name": "listFiles",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[filename, ...]"
          }
        ]
      },
      {
        "name": "move",
        "description": "Moves an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "read",
        "description": "Reads the content of an existing file in binary mode up to a specific byte-based length.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          },
          {
            "name": "position",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readCSV",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[value, ...], ...]"
          }
        ]
      },
      {
        "name": "readJSON",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "setPermissions",
        "description": "Sets the permissions of an exiting file to a specific numeric mode.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "0o777"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setTimeout",
        "description": "Sets the timeout period of this client to a specific number of seconds.",
        "param": [
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setWorkingDirectory",
        "description": "Sets the path of the working directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "upload",
        "description": "Uploads an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          },
          {
            "name": "position",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "write",
        "description": "Writes a string to a file in binary mode up to a specific byte-based length and returns the number of bytes written.",
        "annotation": [
          "If the file exists, its content is overwritten, if it does not exist, it is implicitly created."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          },
          {
            "name": "position",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "Function",
    "static": true,
    "description": "Static function related functions.",
    "method": [
      {
        "name": "call",
        "description": "Calls a function with variadic arguments, optionally bound as a method to a specific object.",
        "param": [
          {
            "name": "function",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "countParameters",
        "description": "Counts the total number of parameters of a function.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "isInternal",
        "description": "Determines whether a function is internal.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isUserDefined",
        "description": "Determines whether a function is user-defined.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isVariadic",
        "description": "Determines whether a function is variadic, meaning it accepts a variable number of arguments.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listParameterNames",
        "description": "Lists all parameter names of a function.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listParameters",
        "description": "Lists all parameters of a function with associated default values.",
        "param": [
          {
            "name": "function",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[name: default, ...]"
          }
        ]
      }
    ]
  },
  {
    "name": "Generator",
    "static": false,
    "extend": "Base",
    "description": "Abstract generator prototype.",
    "method": [
      {
        "name": "getResult",
        "return": [
          {
            "type": "mixed"
          },
          {
            "type": "null",
            "description": "if there is no result yet"
          }
        ]
      },
      {
        "name": "next",
        "description": "Resumes this generator.",
        "return": [
          {
            "type": "object",
            "value": "[key: value]"
          },
          {
            "type": "null",
            "description": "if there is no more to yield"
          }
        ]
      },
      {
        "name": "send",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[key: value]"
          },
          {
            "type": "null",
            "description": "if there is no more to yield"
          }
        ]
      },
      {
        "name": "throw",
        "param": [
          {
            "name": "exception",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[key: value]"
          },
          {
            "type": "null",
            "description": "if there is no more to yield"
          }
        ]
      }
    ]
  },
  {
    "name": "HTTP",
    "static": true,
    "description": "Static HTTP related functions.",
    "method": [
      {
        "name": "canSendHeaders",
        "description": "Determines whether HTTP response headers can be sent.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "clearHeaders",
        "description": "Removes all previously set HTTP response headers."
      },
      {
        "name": "countRequestHeaders",
        "description": "Counts the total number of HTTP request headers.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countResponseHeaders",
        "description": "Counts the total number of HTTP response headers.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getAuthenticationPassword",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getAuthenticationUser",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDocumentRoot",
        "description": "Gets the path of the local server's document root directory.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getLocalAddress",
        "description": "Gets the IP address of the local server.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getLocalHost",
        "description": "Gets the host name of the local server.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getLocalPort",
        "description": "Gets the port number of the local server.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getRemoteAddress",
        "description": "Gets the IP address of the remote client.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRemoteHost",
        "description": "Gets the host name of the remote client.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRemotePort",
        "description": "Gets the port number of the remote client.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getRequestBody",
        "description": "Gets the HTTP request body in raw format.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRequestCookie",
        "description": "Gets the value of a HTTP request cookie.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the cookie is not found"
          }
        ]
      },
      {
        "name": "getRequestFileUpload",
        "description": "Gets the details of a HTTP request file upload.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[\"name\": ..., \"type\": ..., \"tmp_name\": ..., \"error\": ..., \"size\": ...]"
          },
          {
            "type": "null",
            "description": "if the file is not found"
          }
        ]
      },
      {
        "name": "getRequestFormVariable",
        "description": "Gets the value of a HTTP request variable submitted via the POST method with content type \"application/x-www-form-urlencoded\" or \"multipart/form-data\" according to RFC 2388.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the variable is not found"
          }
        ]
      },
      {
        "name": "getRequestHeader",
        "description": "Gets the value of a HTTP request header.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the header is not found"
          }
        ]
      },
      {
        "name": "getRequestMethod",
        "description": "Gets the HTTP request method.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRequestQuery",
        "description": "Gets the query component of the HTTP request URL.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRequestQueryVariable",
        "description": "Gets the value of a HTTP request variable submitted via the URL query component.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the variable is not found"
          }
        ]
      },
      {
        "name": "getRequestType",
        "description": "Gets the content type of the HTTP request.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRequestURL",
        "description": "Gets the complete HTTP request URL.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRequestVariable",
        "description": "Gets the value of a HTTP request variable.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the variable is not found"
          }
        ]
      },
      {
        "name": "getResponseHeader",
        "description": "Gets the value of a HTTP response header.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the header is not found"
          }
        ]
      },
      {
        "name": "getStatusCode",
        "description": "Gets the current HTTP response status code.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "isConnectionAborted",
        "description": "Determines whether the current connection is aborted, meaning the client has disconnected.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isConnectionSecure",
        "description": "Determines whether the current connection is secure, meaning over HTTPS.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listRequestCookies",
        "description": "Lists all HTTP request cookies.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listRequestFileUploads",
        "description": "Lists the details of all HTTP request file uploads submitted via the POST method with content type \"multipart/form-data\" according to RFC 1867.",
        "return": [
          {
            "type": "object",
            "value": "[name: [\"name\": ..., \"type\": ..., \"tmp_name\": ..., \"error\": ..., \"size\": ...], ...]"
          }
        ]
      },
      {
        "name": "listRequestFormVariables",
        "description": "Lists all HTTP request variables submitted via the POST method with content type \"application/x-www-form-urlencoded\" or \"multipart/form-data\" according to RFC 2388.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listRequestHeaderNames",
        "description": "Lists all HTTP request header names.",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listRequestHeaders",
        "description": "Lists all HTTP request headers.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listRequestQueryVariables",
        "description": "Lists all HTTP request variables submitted via the URL query component.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listRequestVariables",
        "description": "Lists all HTTP request variables.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listResponseHeaderNames",
        "description": "Lists all HTTP response header names.",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listResponseHeaders",
        "description": "Lists all HTTP response headers.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "removeHeader",
        "description": "Removes a HTTP response header.",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "removeHeaders",
        "description": "Removes multiple HTTP response headers.",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "request",
        "param": [
          {
            "name": "url",
            "type": "string"
          },
          {
            "name": "method",
            "type": "string",
            "default": "\"GET\""
          },
          {
            "name": "body",
            "type": "string"
          },
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          },
          {
            "name": "validate",
            "type": "bool",
            "default": "true"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[\"url\": ..., \"status\": ..., \"type\": ..., \"time\": ..., \"header\": ..., \"body\": ...]"
          }
        ]
      },
      {
        "name": "requestBody",
        "param": [
          {
            "name": "url",
            "type": "string"
          },
          {
            "name": "method",
            "type": "string",
            "default": "\"GET\""
          },
          {
            "name": "body",
            "type": "string"
          },
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          },
          {
            "name": "validate",
            "type": "bool",
            "default": "true"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "setBasicAuthentication",
        "param": [
          {
            "name": "realm",
            "type": "string"
          }
        ]
      },
      {
        "name": "setCacheExpires",
        "param": [
          {
            "name": "seconds",
            "type": "int",
            "default": "86400"
          }
        ]
      },
      {
        "name": "setCookie",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "string"
          },
          {
            "name": "expires",
            "type": "int"
          },
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "domain",
            "type": "string"
          },
          {
            "name": "secure",
            "type": "bool"
          },
          {
            "name": "httponly",
            "type": "bool"
          }
        ]
      },
      {
        "name": "setHeader",
        "description": "Sets a HTTP response header.",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "string"
          }
        ]
      },
      {
        "name": "setHeaders",
        "description": "Sets multiple HTTP response headers by treating slot names as header names, expanded by a specific prefix, and slot values as non-referential header values.",
        "param": [
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "prefix",
            "type": "string"
          }
        ]
      },
      {
        "name": "setStatusCode",
        "description": "Sets the HTTP response status code.",
        "param": [
          {
            "name": "code",
            "type": "int",
            "default": "200"
          }
        ]
      }
    ]
  },
  {
    "name": "IO",
    "static": true,
    "description": "Static IO related constants, prototypes and functions.",
    "const": [
      {
        "name": "EOL",
        "type": "string",
        "description": "End-of-line sequence"
      }
    ],
    "method": [
      {
        "name": "append",
        "description": "Appends a string to a file and returns the number of bytes written.",
        "annotation": [
          "If the file does not exist, it is implicitly created."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "appendLine",
        "description": "Appends a string appended by an end-of-line sequence to a file and returns the number of bytes written.",
        "annotation": [
          "If the file does not exist, it is implicitly created."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "canExecute",
        "description": "Determines whether a file exists and can be executed.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canRead",
        "description": "Determines whether a file exists and can be read from.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canWrite",
        "description": "Determines whether a file exists and can be written to.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "copy",
        "description": "Copies an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ]
      },
      {
        "name": "countDirectories",
        "description": "Counts the total number of subdirectories in an existing directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countFiles",
        "description": "Counts the total number of files in an existing directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "crc32",
        "description": "Generates the 32-bit cyclic redundancy checksum polynomial of the content of an existing file as a signed integer.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "createDirectories",
        "description": "Creates directories recursively.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "0o777"
          }
        ]
      },
      {
        "name": "createDirectory",
        "description": "Creates a directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "0o777"
          }
        ]
      },
      {
        "name": "createFile",
        "description": "Creates an empty file if it does not exist and return whether it was newly created.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "createHardLink",
        "description": "Creates a hard link to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ]
      },
      {
        "name": "createSymbolicLink",
        "description": "Creates a symbolic link to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ]
      },
      {
        "name": "createTempFile",
        "description": "Creates an empty temporary file and returns its absolute path.",
        "param": [
          {
            "name": "prefix",
            "type": "string",
            "default": "\"z\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "delete",
        "description": "Deletes an existing file.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "deleteIfExists",
        "description": "Deletes a file if it exists and return whether it existed.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "echo",
        "description": "Outputs the content of an existing file and returns the number of bytes outputted.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "execute",
        "description": "Executes a shell command and returns its output.",
        "param": [
          {
            "name": "command",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "executeFlushed",
        "description": "Executes a shell command, immediately flushes its output and returns the exit code.",
        "param": [
          {
            "name": "command",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exists",
        "description": "Determines whether a path exists.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "getFreeSpace",
        "description": "Gets the free space of a filesystem in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "getGroupID",
        "description": "Gets the group ID of an existing file.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getLastAccess",
        "description": "Gets the timestamp for the last access date and time of an existing file.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getLastModified",
        "description": "Gets the timestamp for the last modification date and time of an existing file.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getPermissions",
        "description": "Gets the permissions of an existing file as the numeric mode.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getSize",
        "description": "Gets the size of an existing file in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getTotalSpace",
        "description": "Gets the total space of a filesystem in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "getUsedSpace",
        "description": "Gets the used space of a filesystem in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "getUserID",
        "description": "Gets the user ID of an existing file.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "hasExistingTarget",
        "description": "Determines whether a symbolic link has an existing target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasSameContent",
        "description": "Determines whether two existing files have the same content.",
        "param": [
          {
            "name": "path1",
            "type": "string"
          },
          {
            "name": "path2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isDirectory",
        "description": "Determines whether a path exists and resolves to a directory after following symbolic links.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isFile",
        "description": "Determines whether a path exists and resolves to a file after following symbolic links.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isRegularDirectory",
        "description": "Determines whether a path exists and refers to a regular directory, without following symbolic links.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isRegularFile",
        "description": "Determines whether a path exists and refers to a regular file, without following symbolic links.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isSameFile",
        "description": "Determines whether two existing paths refer to the same physical file on the file system.",
        "param": [
          {
            "name": "path1",
            "type": "string"
          },
          {
            "name": "path2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isSymbolicLink",
        "description": "Determines whether a path exists and refers to a symbolic link.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listDirectories",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[filename, ...]"
          }
        ]
      },
      {
        "name": "listFiles",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[filename, ...]"
          }
        ]
      },
      {
        "name": "move",
        "description": "Moves an existing file to a specific target.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ]
      },
      {
        "name": "quoteCommandArgument",
        "param": [
          {
            "name": "argument",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "read",
        "description": "Reads the content of an existing file up to a specific byte-based length.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readCSV",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[value, ...], ...]"
          }
        ]
      },
      {
        "name": "readJSON",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "readLines",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[line, ...]"
          }
        ]
      },
      {
        "name": "readModifyWrite",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readNonEmptyLines",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[line, ...]"
          }
        ]
      },
      {
        "name": "readSymbolicLink",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "selectReadyStreams",
        "annotation": [
          "The timeout may include microseconds in the fractional part."
        ],
        "param": [
          {
            "name": "read",
            "type": "?object",
            "value": "[key: stream, ...]"
          },
          {
            "name": "write",
            "type": "?object",
            "value": "[key: stream, ...]"
          },
          {
            "name": "exceptional",
            "type": "?object",
            "value": "[key: stream, ...]"
          },
          {
            "name": "timeout",
            "type": "?number",
            "default": "block indefinitely"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "setGroupByID",
        "description": "Sets the group of an exiting file by ID.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "id",
            "type": "int"
          }
        ]
      },
      {
        "name": "setGroupByName",
        "description": "Sets the group of an exiting file by name.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "setLastAccess",
        "description": "Sets the last access date and time of an exiting file to a specific timestamp.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ]
      },
      {
        "name": "setLastModified",
        "description": "Sets the last modification date and time of an exiting file to a specific timestamp.",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ]
      },
      {
        "name": "setPermissions",
        "description": "Sets the permissions of an exiting file to a specific numeric mode.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "0o777"
          }
        ]
      },
      {
        "name": "setUserByID",
        "description": "Sets the user of an exiting file by ID.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "id",
            "type": "int"
          }
        ]
      },
      {
        "name": "setUserByName",
        "description": "Sets the user of an exiting file by name.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "truncate",
        "description": "Truncates an existing file to a specific size in number of bytes.",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "size",
            "type": "int"
          }
        ]
      },
      {
        "name": "write",
        "description": "Writes a string to a file up to a specific byte-based length and returns the number of bytes written.",
        "annotation": [
          "If the file exists, its content is overwritten, if it does not exist, it is implicitly created."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "writeCSV",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "array",
            "type": "object",
            "value": "[[value, ...], ...]"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "writeJSON",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.DirectoryIterator",
    "static": false,
    "extend": "Base",
    "description": "IO directory iterator prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ]
      },
      {
        "name": "hasMore",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "next",
        "return": [
          {
            "type": "object",
            "value": "[path: filename]"
          },
          {
            "type": "null",
            "description": "if there are no more files"
          }
        ]
      },
      {
        "name": "reset",
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.FileStream",
    "static": false,
    "extend": "IO.Stream",
    "description": "IO file stream prototype.",
    "const": [
      {
        "name": "MODE_CREATE",
        "type": "int",
        "description": "File stream create mode, implies write mode"
      },
      {
        "name": "MODE_TRUNCATE",
        "type": "int",
        "description": "File stream truncate mode, implies write mode"
      },
      {
        "name": "MODE_APPEND",
        "type": "int",
        "description": "File stream append mode, implies create mode"
      },
      {
        "name": "MODE_OVERWRITE",
        "type": "int",
        "description": "File stream overwrite mode, same as create plus truncate mode"
      }
    ],
    "method": [
      {
        "name": "construct",
        "description": "Opens a stream to a file in a specific access mode (see MODE_* constants).",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "MODE_READ | MODE_WRITE | MODE_CREATE"
          }
        ]
      },
      {
        "name": "attemptLock",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "attemptLockShared",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canLock",
        "description": "Determines whether this stream can be locked.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "getSize",
        "description": "Gets the size of this stream in number of bytes.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "lock",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "lockShared",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "pad",
        "description": "Pads the content of this stream to a specific size in number of bytes by repeatedly appending it with a specific padding string and returns the number of bytes written.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "size",
            "type": "int"
          },
          {
            "name": "padding",
            "type": "string",
            "default": "\"\\x00\""
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "selectLock",
        "return": [
          {
            "type": "@IO.LockContext"
          }
        ]
      },
      {
        "name": "sync",
        "description": "Synchonizes this stream with the underlying storage device, including modified metadata.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "syncData",
        "description": "Synchonizes this stream with the underlying storage device, excluding modified metadata (if possible).",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "unlock",
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.LockContext",
    "static": false,
    "extend": "Base",
    "description": "Abstract IO lock context prototype.",
    "method": [
      {
        "name": "enter"
      },
      {
        "name": "exit"
      }
    ]
  },
  {
    "name": "IO.Process",
    "static": false,
    "extend": "Base",
    "description": "IO process prototype.",
    "method": [
      {
        "name": "construct",
        "description": "Opens a process by executing a specific command.",
        "param": [
          {
            "name": "command",
            "type": "string"
          },
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "environment",
            "type": "?object",
            "default": "inherited"
          }
        ]
      },
      {
        "name": "close",
        "description": "Closes this process, frees its associated resources and returns its exit code.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this process and frees its associated resources for the purpose of contextualization."
      },
      {
        "name": "getCommand",
        "description": "Gets the command that created this process.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getExitCode",
        "description": "Gets the exit code returned by this process.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getProcessID",
        "description": "Gets the process ID.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "isRunning",
        "description": "Determines whether this process is running.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "selectErrorStream",
        "description": "Selects the error stream of this process.",
        "return": [
          {
            "type": "@IO.Stream"
          }
        ]
      },
      {
        "name": "selectInputStream",
        "description": "Selects the input stream of this process.",
        "return": [
          {
            "type": "@IO.Stream"
          }
        ]
      },
      {
        "name": "selectOutputStream",
        "description": "Selects the output stream of this process.",
        "return": [
          {
            "type": "@IO.Stream"
          }
        ]
      },
      {
        "name": "terminate",
        "description": "Terminates this process without blocking by signaling a termination request.",
        "param": [
          {
            "name": "signal",
            "type": "int",
            "default": "15"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "toString",
        "description": "Converts this process to a string by returning the command that created it.",
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.SocketClient",
    "static": false,
    "extend": "IO.SocketStream",
    "description": "IO socket client prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "endpoint",
            "type": "string"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.SocketServer",
    "static": false,
    "extend": "IO.SocketStream",
    "description": "IO socket server prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "endpoint",
            "type": "string"
          }
        ]
      },
      {
        "name": "accept",
        "param": [
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ],
        "return": [
          {
            "type": "@IO.SocketStream"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.SocketStream",
    "static": false,
    "extend": "IO.Stream",
    "description": "Abstract IO socket stream prototype.",
    "method": [
      {
        "name": "disableEncryption",
        "annotation": [
          "This function is complementary to \"enableEncryption\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "enableEncryption",
        "annotation": [
          "This function is complementary to \"disableEncryption\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "getLocalEndpoint",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getRemoteEndpoint",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "peek",
        "param": [
          {
            "name": "length",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "receive",
        "param": [
          {
            "name": "length",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[string, endpoint]"
          },
          {
            "type": "null",
            "description": "if there is nothing to receive"
          }
        ]
      },
      {
        "name": "receiveOutOfBand",
        "param": [
          {
            "name": "length",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[string, endpoint]"
          },
          {
            "type": "null",
            "description": "if there is nothing to receive"
          }
        ]
      },
      {
        "name": "send",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "endpoint",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "sendOutOfBand",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "endpoint",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "shutdownReceive",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "shutdownSend",
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "IO.Stream",
    "static": false,
    "extend": "Base",
    "description": "Abstract IO stream prototype.",
    "const": [
      {
        "name": "MODE_READ",
        "type": "int",
        "description": "Stream read mode"
      },
      {
        "name": "MODE_WRITE",
        "type": "int",
        "description": "Stream write mode"
      }
    ],
    "method": [
      {
        "name": "canRead",
        "description": "Determines whether this stream can be read from.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canSeek",
        "description": "Determines whether this stream can be sought.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canWrite",
        "description": "Determines whether this stream can be written to.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "close",
        "description": "Closes this stream and frees its associated resources."
      },
      {
        "name": "copyTo",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "stream",
            "type": "@IO.Stream"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "disableBlocking",
        "description": "Disables blocking mode for this stream.",
        "annotation": [
          "This function is complementary to \"enableBlocking\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "echo",
        "description": "Outputs the content of this stream up to a specific byte-based length and returns the number of bytes outputted.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "echoAll",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "echoLine",
        "description": "Outputs the content of this stream as far as and including the next end-of-line sequence and returns the number of bytes outputted.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "enableBlocking",
        "description": "Enables blocking mode for this stream.",
        "annotation": [
          "This function is complementary to \"disableBlocking\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this stream and frees its associated resources for the purpose of contextualization."
      },
      {
        "name": "flush",
        "description": "Flushes the write buffer of this stream.",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "getPosition",
        "description": "Gets the current position within this stream as the number of bytes from its beginning.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getURI",
        "description": "Gets the URI associated with this stream.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hasMore",
        "description": "Determines whether this stream has more content.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasTimedOut",
        "description": "Determines whether this stream has timed out.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isBlocking",
        "description": "Determines whether this stream is in blocking mode.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isLocal",
        "description": "Determines whether this stream is local.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "next",
        "description": "Reads the content of this stream as far as and including the next end-of-line sequence for the purpose of iteration.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "return": [
          {
            "type": "object",
            "value": "[position: line]"
          },
          {
            "type": "null",
            "description": "if there are no more lines"
          }
        ]
      },
      {
        "name": "overwrite",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "pollExceptional",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "pollRead",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "pollWrite",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "read",
        "description": "Reads the content of this stream up to a specific byte-based length.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readAll",
        "description": "Reads the entire content of this stream.",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readLine",
        "description": "Reads the content of this stream as far as and including the next end-of-line sequence.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if there are no more lines"
          }
        ]
      },
      {
        "name": "readLineCSV",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "type": "null",
            "description": "if there are no more lines"
          }
        ]
      },
      {
        "name": "reset",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "seek",
        "annotation": [
          "If the position is negative, it seeks to that many bytes from the end of the stream.",
          "This function may alter the position within the stream."
        ],
        "param": [
          {
            "name": "position",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "seekEnd",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setReadBuffer",
        "description": "Sets the read buffer size of this stream to a specific number of bytes.",
        "annotation": [
          "If the size is zero, read buffering will be disabled."
        ],
        "param": [
          {
            "name": "size",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setTimeout",
        "description": "Sets the timeout period of this stream to a specific number of seconds.",
        "param": [
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setWriteBuffer",
        "description": "Sets the write buffer size of this stream to a specific number of bytes.",
        "annotation": [
          "If the size is zero, write buffering will be disabled."
        ],
        "param": [
          {
            "name": "size",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "skip",
        "annotation": [
          "This function may alter the position within the stream."
        ],
        "param": [
          {
            "name": "offset",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "toString",
        "description": "Converts this stream to a string by returning its associated URI.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "truncate",
        "description": "Truncates this stream to a specific size in number of bytes.",
        "param": [
          {
            "name": "size",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "write",
        "description": "Writes a string to this stream up to a specific byte-based length and returns the number of bytes written.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "writeFormatted",
        "description": "Writes a formatted string to this stream with \"printf\"-compatible format specifiers (\"%...\") substituted with variadic arguments.",
        "annotation": [
          "Complex arguments are interpreted as strings for the purpose of formatting."
        ],
        "param": [
          {
            "name": "format",
            "type": "string"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "writeLine",
        "description": "Writes a string appended by an end-of-line sequence to this stream and returns the number of bytes written.",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "writeLineCSV",
        "annotation": [
          "This function may advance the position within the stream."
        ],
        "param": [
          {
            "name": "array",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\";\""
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "MIME",
    "static": true,
    "description": "Static MIME related functions.",
    "method": [
      {
        "name": "createMultipart",
        "param": [
          {
            "name": "parts",
            "type": "object"
          },
          {
            "name": "boundary",
            "type": "string"
          },
          {
            "name": "preamble",
            "type": "string"
          },
          {
            "name": "epilog",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromBase64",
        "description": "Decodes a string according to RFC 2045 by converting printable characters back to arbitrary byte sequences.",
        "annotation": [
          "MIME Base64 is designed to make binary data survive transmission via transport layers that are not 8-bit clean. MIME Base64-encoded data is about 33 percent larger than the original data.",
          "This function is complementary to \"toBase64\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromBase64URL",
        "description": "Decodes a string according to RFC 2045 by converting printable characters back to arbitrary byte sequences, but using an URL and filename safe alphabet as per RFC 4648.",
        "annotation": [
          "MIME Base64 is designed to make binary data survive transmission via transport layers that are not 8-bit clean. MIME Base64-encoded data is about 33 percent larger than the original data.",
          "This function is complementary to \"toBase64URL\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromEncodedWord",
        "annotation": [
          "This function is complementary to \"toEncodedWord\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromQuotedPrintable",
        "description": "Decodes a string according to RFC 2045 by replacing sequences incipient with an equal sign (\"=\") followed by a 2-character hexadecimal number with their applicable characters.",
        "annotation": [
          "This function is complementary to \"toQuotedPrintable\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isPrintable",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "parseMultipart",
        "param": [
          {
            "name": "body",
            "type": "string"
          },
          {
            "name": "boundary",
            "type": "?string",
            "default": "detect"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[part, ...]"
          },
          {
            "type": "null",
            "description": "if the boundary is not found"
          }
        ]
      },
      {
        "name": "toBase64",
        "description": "Encodes a string in lines of no more than 76 bytes according to RFC 2045 using a 65-character printable subset of US-ASCII to represent arbitrary byte sequences.",
        "annotation": [
          "MIME Base64 is designed to make binary data survive transmission via transport layers that are not 8-bit clean. MIME Base64-encoded data is about 33 percent larger than the original data.",
          "This function is complementary to \"fromBase64\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toBase64Raw",
        "description": "Encodes a string without line breaks according to RFC 2045 using a 65-character printable subset of US-ASCII to represent arbitrary byte sequences.",
        "annotation": [
          "MIME Base64 is designed to make binary data survive transmission via transport layers that are not 8-bit clean. MIME Base64-encoded data is about 33 percent larger than the original data.",
          "This function is complementary to \"fromBase64\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toBase64URL",
        "description": "Encodes a string without line breaks according to RFC 2045 using a 65-character printable subset of US-ASCII to represent arbitrary byte sequences, but using an URL and filename safe alphabet as per RFC 4648.",
        "annotation": [
          "MIME Base64 is designed to make binary data survive transmission via transport layers that are not 8-bit clean. MIME Base64-encoded data is about 33 percent larger than the original data.",
          "This function is complementary to \"fromBase64URL\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toEncodedWord",
        "annotation": [
          "This function is complementary to \"fromEncodedWord\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toQuotedPrintable",
        "description": "Encodes a string in lines of no more than 76 bytes according to RFC 2045 by replacing every unprintable character with an equal sign (\"=\") followed by a 2-character hexadecimal number.",
        "annotation": [
          "This function is complementary to \"fromQuotedPrintable\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "Mail",
    "static": true,
    "description": "Static mail related prototypes and functions.",
    "method": [
      {
        "name": "isValidAddress",
        "param": [
          {
            "name": "address",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "parseMessage",
        "param": [
          {
            "name": "message",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "@Mail.Message"
          }
        ]
      }
    ]
  },
  {
    "name": "Mail.Message",
    "static": false,
    "extend": "Base",
    "description": "Abstract mail message prototype.",
    "method": [
      {
        "name": "clearHeaders",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "countHeaders",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "create",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDisposition",
        "description": "Gets the content disposition of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getFilename",
        "description": "Gets the filename of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getHeader",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "object",
            "value": "[value, ...]",
            "description": "if the header has multiple values"
          },
          {
            "type": "null",
            "description": "if the header is not found"
          }
        ]
      },
      {
        "name": "getTransferEncoding",
        "description": "Gets the content transfer encoding of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getType",
        "description": "Gets the content type of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isAttachment",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listHeaderNames",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listHeaders",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "removeHeader",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "removeHeaders",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setHeader",
        "description": "Sets a mail header.",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setHeaders",
        "description": "Sets multiple mail headers by treating slot names as header names, expanded by a specific prefix, and slot values as non-referential header values.",
        "param": [
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "prefix",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setDisposition",
        "description": "Sets the content disposition of this message.",
        "param": [
          {
            "name": "disposition",
            "type": "string"
          },
          {
            "name": "filename",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setTransferEncoding",
        "description": "Sets the content transfer encoding of this message.",
        "param": [
          {
            "name": "encoding",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setType",
        "description": "Sets the content type of this message.",
        "param": [
          {
            "name": "type",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "Mail.MultipartMessage",
    "static": false,
    "extend": "Mail.Message",
    "description": "Multipart mail message prototype.",
    "method": [
      {
        "name": "construct"
      },
      {
        "name": "addPart",
        "param": [
          {
            "name": "message",
            "type": "@Mail.Message"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "attach",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "filename",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string",
            "default": "\"application/octet-stream\""
          }
        ],
        "return": [
          {
            "type": "@Mail.SimpleMessage"
          }
        ]
      },
      {
        "name": "attachFile",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "filename",
            "type": "?string",
            "default": "derived from path"
          },
          {
            "name": "type",
            "type": "string",
            "default": "\"application/octet-stream\""
          }
        ],
        "return": [
          {
            "type": "@Mail.SimpleMessage"
          }
        ]
      },
      {
        "name": "clearParts",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "countParts",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getBoundary",
        "description": "Gets the boundary delimiter of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "listParts",
        "return": [
          {
            "type": "object",
            "value": "[message, ...]"
          }
        ]
      },
      {
        "name": "removePart",
        "param": [
          {
            "name": "message",
            "type": "@Mail.Message"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setBoundary",
        "description": "Sets the boundary delimiter of this message.",
        "param": [
          {
            "name": "boundary",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "Mail.SimpleMessage",
    "static": false,
    "extend": "Mail.Message",
    "description": "Simple mail message prototype.",
    "method": [
      {
        "name": "construct"
      },
      {
        "name": "getBody",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getBodyRaw",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getCharset",
        "description": "Gets the character set of this message.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isText",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "setBody",
        "param": [
          {
            "name": "body",
            "type": "string"
          },
          {
            "name": "encoding",
            "type": "?string",
            "default": "current encoding"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setBodyRaw",
        "param": [
          {
            "name": "body",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setCharset",
        "param": [
          {
            "name": "charset",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setText",
        "param": [
          {
            "name": "text",
            "type": "string"
          },
          {
            "name": "charset",
            "type": "?string",
            "default": "current charset or UTF-8 if empty"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "Math",
    "static": true,
    "description": "Static mathematical constants and functions.",
    "const": [
      {
        "name": "E",
        "type": "float",
        "description": "Euler's number and the base of natural logarithms, approximately 2.718"
      },
      {
        "name": "LN2",
        "type": "float",
        "description": "Natural logarithm of 2, approximately 0.693"
      },
      {
        "name": "LN10",
        "type": "float",
        "description": "Natural logarithm of 10, approximately 2.303"
      },
      {
        "name": "LNPI",
        "type": "float",
        "description": "Natural logarithm of PI, approximately 1.145"
      },
      {
        "name": "LOG10E",
        "type": "float",
        "description": "Base 10 logarithm of E, approximately 0.434"
      },
      {
        "name": "LOG2E",
        "type": "float",
        "description": "Base 2 logarithm of E, approximately 1.443"
      },
      {
        "name": "PI",
        "type": "float",
        "description": "Ratio of the circumference of a circle to its diameter, approximately 3.142"
      },
      {
        "name": "SQRT2",
        "type": "float",
        "description": "Square root of 2, approximately 1.414"
      },
      {
        "name": "SQRT3",
        "type": "float",
        "description": "Square root of 3, approximately 1.732"
      },
      {
        "name": "SQRTPI",
        "type": "float",
        "description": "Square root of PI, approximately 1.772"
      }
    ],
    "method": [
      {
        "name": "abs",
        "description": "Returns the absolute value of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "acos",
        "description": "Calculates the inverse cosine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is less than minus one or greater than plus one"
          }
        ]
      },
      {
        "name": "acosh",
        "description": "Calculates the inverse hyperbolic cosine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "acot",
        "description": "Calculates the inverse cotangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "acoth",
        "description": "Calculates the inverse hyperbolic cotangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is plus one"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the number is minus one"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero or less than plus one and greater than minus one"
          }
        ]
      },
      {
        "name": "acsc",
        "description": "Calculates the inverse cosecant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero or less than plus one and greater than minus one"
          }
        ]
      },
      {
        "name": "acsch",
        "description": "Calculates the inverse hyperbolic cosecant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "add",
        "description": "Adds two numbers (x+y) and returns the sum.",
        "annotation": [
          "This function is equivalent to the \"+\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if one summand is +INF and the other is -INF"
          }
        ]
      },
      {
        "name": "alice",
        "description": "Easter egg simulating quantum entanglement of two electrons (Alice and Bob).",
        "annotation": [
          "This function is complementary to \"bob\"."
        ],
        "return": [
          {
            "type": "float",
            "value": "+0.5",
            "description": "spin up"
          },
          {
            "type": "float",
            "value": "-0.5",
            "description": "spin down"
          }
        ]
      },
      {
        "name": "asec",
        "description": "Calculates the inverse secant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero or less than plus one and greater than minus one"
          }
        ]
      },
      {
        "name": "asech",
        "description": "Calculates the inverse hyperbolic secant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "asin",
        "description": "Calculates the inverse sine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is less than minus one or greater than plus one"
          }
        ]
      },
      {
        "name": "asinh",
        "description": "Calculates the inverse hyperbolic sine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "atan",
        "description": "Calculates the inverse tangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "atan2",
        "description": "Calculates the inverse tangent of the division of two numbers (y/x) representing the angle theta of an (x,y) point in radians using the sign of both numbers to determine the quadrant.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "atanh",
        "description": "Calculates the inverse hyperbolic tangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is plus one"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the number is minus one"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is less than minus one or greater than plus one"
          }
        ]
      },
      {
        "name": "bob",
        "description": "Easter egg simulating quantum entanglement of two electrons (Alice and Bob).",
        "annotation": [
          "This function is complementary to \"alice\"."
        ],
        "return": [
          {
            "type": "float",
            "value": "+0.5",
            "description": "spin up"
          },
          {
            "type": "float",
            "value": "-0.5",
            "description": "spin down"
          }
        ]
      },
      {
        "name": "cbrt",
        "description": "Calculates the principal cube root of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "ceil",
        "description": "Returns the ceiling of a number by rounding it up to the next highest integer.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "cos",
        "description": "Calculates the cosine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "cosh",
        "description": "Calculates the hyperbolic cosine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "cot",
        "description": "Calculates the cotangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "coth",
        "description": "Calculates the hyperbolic cotangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "csc",
        "description": "Calculates the cosecant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "csch",
        "description": "Calculates the hyperbolic cosecant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "dim",
        "description": "Returns the greatest of zero and the difference of two numbers (x-y).",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if any number is NaN"
          }
        ]
      },
      {
        "name": "div",
        "description": "Divides two numbers (x/y) and returns the quotient.",
        "annotation": [
          "This function is equivalent to the \"/\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the dividend is greater than zero and the divisor is zero"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the dividend is less than zero and the divisor is zero"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the dividend and the divisor are zero or +-INF"
          }
        ]
      },
      {
        "name": "erf",
        "description": "Calculates the error function of a number using numerical approximation.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "euclideanMod",
        "description": "Divides two numbers (x/y) and returns the remainder in relation to the euclidean quotient.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the divisor is zero"
          }
        ]
      },
      {
        "name": "exp",
        "description": "Raises Euler's constant to the power of an exponent (x).",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "expm1",
        "description": "Raises Euler's constant to the power of an exponent (x) minus one (exp(x)-1), computed in a way that is accurate even when the value of the number is close to zero.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "fib",
        "description": "Calculates a specific Fibonacci number using Binet's formula.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "floor",
        "description": "Returns the floor of a number by rounding it down to the next lowest integer.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "flooredMod",
        "description": "Divides two numbers (x/y) and returns the remainder in relation to the floored quotient.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the divisor is zero"
          }
        ]
      },
      {
        "name": "fromDegrees",
        "description": "Converts an angle in degrees to its equivalent in radians.",
        "annotation": [
          "This function is complementary to \"toDegrees\"."
        ],
        "param": [
          {
            "name": "angle",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "gamma",
        "description": "Calculates the gamma function of a number using the Lanczos approximation with support for reflection.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is a non-positive integer or -INF"
          }
        ]
      },
      {
        "name": "gcd",
        "description": "Calculates the absolute greatest common divisor of two numbers.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if any number is NaN, +-INF or has a fractional part"
          }
        ]
      },
      {
        "name": "hypot",
        "description": "Measures the length of the hypotenuse of a right-angle triangle (sqrt(x*x+y*y)).",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "ln",
        "description": "Calculates the natural logarithm of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the number is zero"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is negative"
          }
        ]
      },
      {
        "name": "ln1p",
        "description": "Calculates the natural logarithm of a number plus one (ln(x+1)), computed in a way that is accurate even when the value of the number is close to zero.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the number is minus one"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is less than minus one"
          }
        ]
      },
      {
        "name": "log",
        "description": "Calculates the logarithm of a number (x) to a base (y).",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number",
            "default": "10"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the number is zero"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is negative or if the base is less than or equal to zero"
          }
        ]
      },
      {
        "name": "mod",
        "description": "Divides two numbers (x/y) and returns the remainder in relation to the truncated quotient.",
        "annotation": [
          "This function is equivalent to the \"%\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the divisor is zero"
          }
        ]
      },
      {
        "name": "mul",
        "description": "Multiplies two numbers (x*y) and returns the product.",
        "annotation": [
          "This function is equivalent to the \"*\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if one multiplicand is zero and the other is +-INF"
          }
        ]
      },
      {
        "name": "neg",
        "description": "Returns the additive inverse of a number.",
        "annotation": [
          "This function is equivalent to the unary \"-\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "pow",
        "description": "Raises a base (x) to the power of an exponent (y).",
        "annotation": [
          "This function is equivalent to the \"**\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number",
            "default": "10"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the base is zero and the exponent is negative"
          }
        ]
      },
      {
        "name": "rand",
        "description": "Generates a pseudo-random number between zero and one using the Mersenne Twister algorithm.",
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "recip",
        "description": "Returns the multiplicative inverse (reciprocal, 1/x) of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the number is zero"
          }
        ]
      },
      {
        "name": "rem",
        "description": "Divides two numbers (x/y) and returns the remainder in relation to the rounded quotient as defined in IEEE 754.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the divisor is zero"
          }
        ]
      },
      {
        "name": "round",
        "description": "Rounds a number to nearest, ties to even as defined in IEEE 754.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "sec",
        "description": "Calculates the secant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "sech",
        "description": "Calculates the hyperbolic secant of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "sgn",
        "description": "Returns the sign of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "int",
            "value": "+1",
            "description": "if the number is positive"
          },
          {
            "type": "int",
            "value": "-1",
            "description": "if the number is negative"
          },
          {
            "type": "int",
            "value": "0",
            "description": "if the number is zero"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is NaN"
          }
        ]
      },
      {
        "name": "sin",
        "description": "Calculates the sine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "sinh",
        "description": "Calculates the hyperbolic sine of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "sqr",
        "description": "Calculates the square of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "sqrt",
        "description": "Calculates the principal square root of a number.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the number is negative"
          }
        ]
      },
      {
        "name": "sub",
        "description": "Subtracts two numbers (x-y) and returns the difference.",
        "annotation": [
          "This function is equivalent to the \"-\" operator."
        ],
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the minuend is +-INF and the subtrahend is the additive inverse of the minuend"
          }
        ]
      },
      {
        "name": "tan",
        "description": "Calculates the tangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "tanh",
        "description": "Calculates the hyperbolic tangent of a number in radians.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "toDegrees",
        "description": "Converts an angle in radians to its equivalent in degrees.",
        "annotation": [
          "This function is complementary to \"fromDegrees\"."
        ],
        "param": [
          {
            "name": "angle",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "truncate",
        "description": "Truncates a number by rounding it towards zero, whereas the fractional part is discarded.",
        "param": [
          {
            "name": "x",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "truncatedDiv",
        "description": "Divides two numbers (x/y) and returns the truncated quotient.",
        "param": [
          {
            "name": "x",
            "type": "number"
          },
          {
            "name": "y",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "+INF",
            "description": "if the dividend is greater than zero and the divisor is zero"
          },
          {
            "type": "float",
            "value": "-INF",
            "description": "if the dividend is less than zero and the divisor is zero"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if the dividend and the divisor are zero or +-INF"
          }
        ]
      }
    ]
  },
  {
    "name": "Number",
    "static": true,
    "description": "Static number related constants and functions.",
    "const": [
      {
        "name": "EPSILON",
        "type": "float",
        "description": "Machine epsilon or unit roundoff, which is defined as the smallest value that, when added to one, yields a result greater than one"
      },
      {
        "name": "INF",
        "type": "float",
        "description": "Special value representing infinity; returned on overflow"
      },
      {
        "name": "MINFLOAT",
        "type": "float",
        "description": "Minimum value of type \"float\""
      },
      {
        "name": "MININT",
        "type": "int",
        "description": "Minimum value of type \"int\""
      },
      {
        "name": "MAXFLOAT",
        "type": "float",
        "description": "Maximum value of type \"float\""
      },
      {
        "name": "MAXINT",
        "type": "int",
        "description": "Maximum value of type \"int\""
      },
      {
        "name": "NAN",
        "type": "float",
        "description": "Special \"not a number\" value"
      }
    ],
    "method": [
      {
        "name": "compare",
        "description": "Compares two numbers in a numeric manner.",
        "annotation": [
          "This function is equivalent to the \"<=>\" operator on numbers."
        ],
        "param": [
          {
            "name": "number1",
            "type": "number"
          },
          {
            "name": "number2",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "int",
            "value": "+1",
            "description": "if the first number is greater than the second number"
          },
          {
            "type": "int",
            "value": "-1",
            "description": "if the first number is less than the second number"
          },
          {
            "type": "int",
            "value": "0",
            "description": "if both numbers are equal or any number is NaN"
          }
        ]
      },
      {
        "name": "countLeadingZeros",
        "description": "Counts the leading zeros of an unsigned integer number.",
        "param": [
          {
            "name": "number",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "equals",
        "description": "Determines whether two numbers are equal, considering the machine epsilon.",
        "annotation": [
          "This function is equivalent to the \"==\" operator on numbers."
        ],
        "param": [
          {
            "name": "number1",
            "type": "number"
          },
          {
            "name": "number2",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "format",
        "description": "Returns the formatted representation of a number with separated thousands, rounded with a specific precision.",
        "annotation": [
          "The rounding mechanism of this function is analog to \"roundHalfToInfinity\"."
        ],
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          },
          {
            "name": "point",
            "type": "string",
            "default": "\".\""
          },
          {
            "name": "separator",
            "type": "string",
            "default": "\" \""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromBinary",
        "description": "Converts a binary string representation to its equivalent decimal number.",
        "annotation": [
          "This function is complementary to \"toBinary\"."
        ],
        "param": [
          {
            "name": "binary",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "fromHex",
        "description": "Converts a hexadecimal string representation to its equivalent decimal number.",
        "annotation": [
          "This function is complementary to \"toHex\"."
        ],
        "param": [
          {
            "name": "hex",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "fromOctal",
        "description": "Converts an octal string representation to its equivalent decimal number.",
        "annotation": [
          "This function is complementary to \"toOctal\"."
        ],
        "param": [
          {
            "name": "octal",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "hasFractionalPart",
        "description": "Determines whether a number has a fractional part.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasIntegerPart",
        "description": "Determines whether a number has an integer part.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isBigEndian",
        "description": "Determines whether the machine is of a big-endian architecture.",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isEven",
        "description": "Determines whether a number is even.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isFinite",
        "description": "Determines whether a number is finite.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isInfinite",
        "description": "Determines whether a number is infinite.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNaN",
        "description": "Determines whether a number is \"not a number\" (NaN).",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNatural",
        "description": "Determines whether a number is in the set of natural numbers including zero.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNegative",
        "description": "Determines whether a number is negative.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isOdd",
        "description": "Determines whether a number is odd.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isPositive",
        "description": "Determines whether a number is positive.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isPrime",
        "description": "Determines whether a number is a prime number.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isSafeInteger",
        "description": "Determines whether a number is a whole number within the safe integer range.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isZero",
        "description": "Determines whether a number equals zero.",
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "max",
        "description": "Returns the greatest of numbers.",
        "param": [
          {
            "name": "numbers",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if any number is NaN"
          },
          {
            "type": "null",
            "description": "if there are no numbers"
          }
        ]
      },
      {
        "name": "min",
        "description": "Returns the least of numbers.",
        "param": [
          {
            "name": "numbers",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if any number is NaN"
          },
          {
            "type": "null",
            "description": "if there are no numbers"
          }
        ]
      },
      {
        "name": "normalize",
        "description": "Normalizes a number by stripping binary floating-point artifacts.",
        "annotation": [
          "This function returns type \"int\" if the cleaned number is a whole number within the IEEE 754 safe integer range."
        ],
        "param": [
          {
            "name": "number",
            "type": "number"
          }
        ],
        "return": [
          {
            "type": "number"
          }
        ]
      },
      {
        "name": "randomFloat",
        "description": "Generates a floating-point number between two numbers from a random source.",
        "param": [
          {
            "name": "min",
            "type": "number"
          },
          {
            "name": "max",
            "type": "number",
            "default": "MAXINT"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "float",
            "value": "NAN",
            "description": "if any number is NaN or +-INF"
          }
        ]
      },
      {
        "name": "randomInt",
        "description": "Generates an integer number between two numbers from a random source.",
        "param": [
          {
            "name": "min",
            "type": "int"
          },
          {
            "name": "max",
            "type": "int",
            "default": "MAXINT"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "roundDown",
        "description": "Rounds a number downwards to negative infinity with a specific precision.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfDown",
        "description": "Rounds a number downwards to nearest with a specific precision, ties towards negative infinity.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfToEven",
        "description": "Rounds a number symmetrically to nearest with a specific precision, ties to even.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfToOdd",
        "description": "Rounds a number symmetrically to nearest with a specific precision, ties to odd.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfToInfinity",
        "description": "Rounds a number symmetrically to nearest with a specific precision, ties towards infinity.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfToZero",
        "description": "Rounds a number symmetrically to nearest with a specific precision, ties towards zero.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundHalfUp",
        "description": "Rounds a number upwards to nearest with a specific precision, ties towards positive infinity.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundToInfinity",
        "description": "Rounds a number symmetrically towards infinity with a specific precision.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundToZero",
        "description": "Rounds a number symmetrically towards zero with a specific precision.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "roundUp",
        "description": "Rounds a number upwards to positive infinity with a specific precision.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "precision",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "toBinary",
        "description": "Converts a decimal number to its equivalent binary string representation.",
        "annotation": [
          "This function is complementary to \"fromBinary\"."
        ],
        "param": [
          {
            "name": "decimal",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toExponential",
        "description": "Converts a number to its equivalent string representation in exponential notation with a fixed number of decimal digits.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "digits",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toFixed",
        "description": "Converts a number to its equivalent string representation in fixed-point notation with a fixed number of decimal digits.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "digits",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toHex",
        "description": "Converts a decimal number to its equivalent hexadecimal string representation.",
        "annotation": [
          "This function is complementary to \"fromHex\"."
        ],
        "param": [
          {
            "name": "decimal",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toOctal",
        "description": "Converts a decimal number to its equivalent octal string representation.",
        "annotation": [
          "This function is complementary to \"fromOctal\"."
        ],
        "param": [
          {
            "name": "decimal",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toPrecision",
        "description": "Converts a number to its equivalent string representation in fixed-point or exponential notation with a maximum number of significant digits.",
        "param": [
          {
            "name": "number",
            "type": "number"
          },
          {
            "name": "digits",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "Output",
    "static": true,
    "description": "Static standard output related prototypes and functions.",
    "method": [
      {
        "name": "clear",
        "description": "Clears the output buffer."
      },
      {
        "name": "echo",
        "description": "Outputs strings.",
        "annotation": [
          "This function is equivalent to the \"echo\" statement."
        ],
        "param": [
          {
            "name": "strings",
            "type": "variadic"
          }
        ]
      },
      {
        "name": "flush",
        "description": "Flushes the output buffer."
      },
      {
        "name": "getContent",
        "description": "Gets the content of the current output buffer.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getLevel",
        "description": "Gets the nesting level of output buffering.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getSize",
        "description": "Gets the size of the current output buffer in number of bytes.",
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "Path",
    "static": true,
    "description": "Static path related constants and functions.",
    "const": [
      {
        "name": "DIRECTORYSEPARATOR",
        "type": "string"
      },
      {
        "name": "MAXLENGTH",
        "type": "int"
      },
      {
        "name": "PATHSEPARATOR",
        "type": "string"
      }
    ],
    "method": [
      {
        "name": "fromURI",
        "description": "Converts a file URI to a path.",
        "annotation": [
          "This function is complementary to \"toURI\"."
        ],
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getBase",
        "description": "Gets the base name component of a path (including extension).",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDirectory",
        "description": "Gets the directory name component of a path.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getExtension",
        "description": "Gets the file extension component of a path.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getFile",
        "description": "Gets the filename component of a path (excluding extension).",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getTempDirectory",
        "description": "Gets the absolute path of the system's directory for temporary files.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getWorkingDirectory",
        "description": "Gets the absolute path of the current working directory.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hasExtension",
        "description": "Determines whether a path has a file extension component.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isAbsolute",
        "description": "Determines whether a path is absolute.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "normalize",
        "description": "Normalizes a path to its canonicalized representation.",
        "annotation": [
          "Removes dot-segments from path."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "parse",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[\"directory\": ..., \"file\": ..., \"extension\": ...]"
          }
        ]
      },
      {
        "name": "setWorkingDirectory",
        "description": "Sets the path of the working directory.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ]
      },
      {
        "name": "toAbsolutePath",
        "description": "Converts a path to its canonicalized absolute path.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toRealPath",
        "description": "Converts a path to the canonicalized absolute path of an existing file, resolving all symbolic links.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toURI",
        "description": "Converts a path to a file URI.",
        "annotation": [
          "This function is complementary to \"fromURI\"."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "REST",
    "static": true,
    "description": "Static RESTful related prototypes."
  },
  {
    "name": "REST.Client",
    "static": false,
    "extend": "Base",
    "description": "RESTful client prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "url",
            "type": "string"
          },
          {
            "name": "callback_request",
            "type": "?function",
            "default": "pass through"
          },
          {
            "name": "callback_response",
            "type": "?function",
            "default": "universal handler"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          },
          {
            "name": "validate",
            "type": "bool",
            "default": "true"
          }
        ]
      },
      {
        "name": "bind",
        "param": [
          {
            "name": "route",
            "type": "string"
          },
          {
            "name": "method",
            "type": "string",
            "default": "\"GET\""
          },
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "function"
          }
        ]
      },
      {
        "name": "call",
        "param": [
          {
            "name": "route",
            "type": "string"
          },
          {
            "name": "method",
            "type": "string",
            "default": "\"GET\""
          },
          {
            "name": "headers",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "setLocation",
        "param": [
          {
            "name": "url",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setTimeout",
        "param": [
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setValidate",
        "param": [
          {
            "name": "validate",
            "type": "bool",
            "default": "true"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "REST.Server",
    "static": false,
    "extend": "Base",
    "description": "RESTful server prototype.",
    "method": [
      {
        "name": "construct"
      },
      {
        "name": "bind",
        "param": [
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "route",
            "type": "string"
          },
          {
            "name": "method",
            "type": "string",
            "default": "\"GET\""
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "bindMethods",
        "param": [
          {
            "name": "routes",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "handle",
        "return": [
          {
            "type": "mixed"
          }
        ]
      }
    ]
  },
  {
    "name": "Regex",
    "static": true,
    "description": "Static regular expression functions.",
    "method": [
      {
        "name": "count",
        "description": "Counts the total number of matches of a global regular expression search of a string against a specific pattern.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "escape",
        "description": "Escapes all regular expression meta characters in a string with backslashes.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\"/\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isValidPattern",
        "description": "Determines whether a regular expression pattern is valid.",
        "param": [
          {
            "name": "pattern",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "match",
        "description": "Returns the first match of a regular expression search of a string against a specific pattern.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[pattern-match, subpattern-match, ...]"
          },
          {
            "type": "null",
            "description": "if the pattern is not found"
          }
        ]
      },
      {
        "name": "matchAll",
        "description": "Returns all matches of a global regular expression search of a string against a specific pattern.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[[pattern-match, subpattern-match, ...], ...]"
          },
          {
            "type": "null",
            "description": "if the pattern is not found"
          }
        ]
      },
      {
        "name": "replace",
        "description": "Replaces all matches of a global regular expression search of a string against a specific pattern with a specific replacement.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "replacement",
            "type": "string"
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "replaceMultiple",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "replacements",
            "type": "object",
            "value": "[pattern: replacement, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "split",
        "description": "Splits a string into isolated substrings on boundaries formed by a specific pattern, whereas empty substrings are retained.",
        "annotation": [
          "This function returns an empty object for an empty string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substr, ...]"
          }
        ]
      },
      {
        "name": "splitNonEmpty",
        "description": "Splits a string into isolated substrings on boundaries formed by a specific pattern, whereas empty substrings are discarded.",
        "annotation": [
          "This function returns an empty object for an empty string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substring, ...]"
          }
        ]
      },
      {
        "name": "substitute",
        "description": "Substitutes all matches of a global regular expression search of a string against a specific pattern with individual replacements provided by a specific callback function.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "bind",
            "type": "?object"
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "test",
        "description": "Tests a regular expression search of a string against a specific pattern for a successful match.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string.",
          "This function is equivalent to the \"~=\" operator."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "pattern",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      }
    ]
  },
  {
    "name": "SOAP",
    "static": true,
    "description": "Static SOAP related prototypes."
  },
  {
    "name": "SOAP.Client",
    "static": false,
    "extend": "Base",
    "description": "SOAP client prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "wsdl",
            "type": "string"
          },
          {
            "name": "username",
            "type": "string"
          },
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ]
      },
      {
        "name": "bind",
        "param": [
          {
            "name": "operation",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "function"
          }
        ]
      },
      {
        "name": "call",
        "param": [
          {
            "name": "operation",
            "type": "string"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "listOperations",
        "return": [
          {
            "type": "object",
            "value": "[signature, ...]"
          }
        ]
      },
      {
        "name": "listTypes",
        "return": [
          {
            "type": "object",
            "value": "[signature, ...]"
          }
        ]
      },
      {
        "name": "setCookie",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setLocation",
        "param": [
          {
            "name": "url",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setTimeout",
        "param": [
          {
            "name": "timeout",
            "type": "int",
            "default": "60"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "SOAP.Server",
    "static": false,
    "extend": "Base",
    "description": "SOAP server prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "wsdl",
            "type": "string"
          }
        ]
      },
      {
        "name": "bind",
        "param": [
          {
            "name": "callback",
            "type": "function"
          },
          {
            "name": "operation",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "bindMethods",
        "param": [
          {
            "name": "operations",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "handle"
      }
    ]
  },
  {
    "name": "SQL",
    "static": true,
    "description": "Static SQL related prototypes and functions.",
    "method": [
      {
        "name": "createSearchCondition",
        "param": [
          {
            "name": "query",
            "type": "string"
          },
          {
            "name": "fields",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "prepare",
        "param": [
          {
            "name": "query",
            "type": "string"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "quoteIdentifier",
        "param": [
          {
            "name": "identifiers",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "quoteLiteral",
        "param": [
          {
            "name": "literals",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.Connection",
    "static": false,
    "extend": "Base",
    "description": "Abstract SQL connection prototype.",
    "method": [
      {
        "name": "begin",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "close",
        "description": "Closes this connection and frees its associated resources."
      },
      {
        "name": "commit",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "countAffectedRows",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countRowsInTable",
        "param": [
          {
            "name": "table",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "delete",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exists",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this connection and frees its associated resources for the purpose of contextualization."
      },
      {
        "name": "fetchAll",
        "param": [
          {
            "name": "query",
            "type": "string"
          },
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[row, ...]"
          }
        ]
      },
      {
        "name": "fetchAllOfField",
        "param": [
          {
            "name": "query",
            "type": "string"
          },
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          }
        ]
      },
      {
        "name": "fetchOne",
        "param": [
          {
            "name": "query",
            "type": "string"
          },
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "type": "null",
            "description": "if the result set is empty"
          }
        ]
      },
      {
        "name": "getCharset",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDatabaseName",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getDatabaseSize",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getLastInsertID",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getVersion",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "insert",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "data",
            "type": "object",
            "value": "[field: value, ...]"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "listFieldsInTable",
        "param": [
          {
            "name": "table",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[field, ...]"
          }
        ]
      },
      {
        "name": "listTables",
        "return": [
          {
            "type": "object",
            "value": "[table, ...]"
          }
        ]
      },
      {
        "name": "query",
        "param": [
          {
            "name": "query",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "SQL.ResultSet"
          },
          {
            "type": "null",
            "description": "if the query is a non-SELECT"
          }
        ]
      },
      {
        "name": "releaseSavepoint",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "rollback",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "rollbackToSavepoint",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "savepoint",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "selectAll",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "fields",
            "type": "object",
            "value": "[field, ...]"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "orderby",
            "type": "object",
            "value": "[field: descending, ...]"
          },
          {
            "name": "limit",
            "type": "int"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[row, ...]"
          }
        ]
      },
      {
        "name": "selectAllOfField",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "field",
            "type": "string"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "orderby",
            "type": "object",
            "value": "[field: descending, ...]"
          },
          {
            "name": "limit",
            "type": "int"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          }
        ]
      },
      {
        "name": "selectOne",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "fields",
            "type": "object",
            "value": "[field, ...]"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "orderby",
            "type": "object",
            "value": "[field: descending, ...]"
          },
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "type": "null",
            "description": "if the result set is empty"
          }
        ]
      },
      {
        "name": "selectSavepoint",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "@SQL.SavepointContext"
          }
        ]
      },
      {
        "name": "selectTransaction",
        "return": [
          {
            "type": "@SQL.TransactionContext"
          }
        ]
      },
      {
        "name": "setCharset",
        "param": [
          {
            "name": "charset",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "update",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "data",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "updateOrInsert",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "data",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "conditions",
            "type": "object",
            "value": "[field: value, ...]"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.MySQL",
    "static": false,
    "extend": "SQL.Connection",
    "description": "MySQL connection prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "server",
            "type": "string"
          },
          {
            "name": "dbname",
            "type": "string"
          },
          {
            "name": "username",
            "type": "string"
          },
          {
            "name": "password",
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.PostgreSQL",
    "static": false,
    "extend": "SQL.Connection",
    "description": "PostgreSQL connection prototype.",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "server",
            "type": "string"
          },
          {
            "name": "dbname",
            "type": "string"
          },
          {
            "name": "username",
            "type": "string"
          },
          {
            "name": "password",
            "type": "string"
          }
        ]
      },
      {
        "name": "disableTracing",
        "annotation": [
          "This function is complementary to \"enableTracing\"."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "enableTracing",
        "annotation": [
          "This function is complementary to \"disableTracing\"."
        ],
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "getHost",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPort",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "insertReturning",
        "param": [
          {
            "name": "table",
            "type": "string"
          },
          {
            "name": "data",
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "name": "fields",
            "type": "object",
            "value": "[field, ...]"
          },
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[field: value, ...]"
          },
          {
            "type": "null",
            "description": "if no row was inserted"
          }
        ]
      },
      {
        "name": "isConnected",
        "return": [
          {
            "type": "bool"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.ResultSet",
    "static": false,
    "extend": "Base",
    "description": "Abstract SQL result set prototype.",
    "method": [
      {
        "name": "close",
        "description": "Closes this result set and frees its associated resources."
      },
      {
        "name": "countFields",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countRows",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this result set and frees its associated resources for the purpose of contextualization."
      },
      {
        "name": "fetch",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "param": [
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object"
          },
          {
            "type": "null",
            "description": "if there are no more rows"
          }
        ]
      },
      {
        "name": "fetchAll",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "param": [
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[row, ...]"
          }
        ]
      },
      {
        "name": "fetchAllOfField",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "param": [
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          }
        ]
      },
      {
        "name": "fetchTail",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "param": [
          {
            "name": "indexed",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[row, ...]"
          }
        ]
      },
      {
        "name": "fetchTailOfField",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "param": [
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          }
        ]
      },
      {
        "name": "getFieldName",
        "param": [
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getFieldTable",
        "param": [
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getFieldType",
        "param": [
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPosition",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "hasMore",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listFieldNames",
        "return": [
          {
            "type": "object",
            "value": "[field, ...]"
          }
        ]
      },
      {
        "name": "next",
        "annotation": [
          "This function may advance the position within the result set."
        ],
        "return": [
          {
            "type": "object",
            "value": "[position: row]"
          },
          {
            "type": "null",
            "description": "if there are no more rows"
          }
        ]
      },
      {
        "name": "reset",
        "annotation": [
          "This function may alter the position within the result set."
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "seek",
        "annotation": [
          "If the position is negative, it seeks to that many rows from the end of the result set.",
          "This function may alter the position within the result set."
        ],
        "param": [
          {
            "name": "position",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "skip",
        "annotation": [
          "This function may alter the position within the result set."
        ],
        "param": [
          {
            "name": "offset",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.SQLite3",
    "static": false,
    "extend": "SQL.Connection",
    "description": "SQLite3 connection prototype.",
    "const": [
      {
        "name": "MODE_READ",
        "type": "int",
        "description": "SQLite3 read mode"
      },
      {
        "name": "MODE_WRITE",
        "type": "int",
        "description": "SQLite3 write mode, implies read mode"
      },
      {
        "name": "MODE_CREATE",
        "type": "int",
        "description": "SQLite3 create mode, implies write mode"
      }
    ],
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "MODE_READ | MODE_WRITE | MODE_CREATE"
          },
          {
            "name": "key",
            "type": "string"
          }
        ]
      },
      {
        "name": "createAggregate",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "callback_step",
            "type": "function"
          },
          {
            "name": "callback_final",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "createCollation",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "callback",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "createFunction",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "callback",
            "type": "function"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.SavepointContext",
    "static": false,
    "extend": "Base",
    "description": "Abstract SQL savepoint context prototype.",
    "method": [
      {
        "name": "enter"
      },
      {
        "name": "exit",
        "param": [
          {
            "name": "exception",
            "type": "mixed"
          }
        ]
      }
    ]
  },
  {
    "name": "SQL.TransactionContext",
    "static": false,
    "extend": "Base",
    "description": "Abstract SQL transaction context prototype.",
    "method": [
      {
        "name": "enter"
      },
      {
        "name": "exit",
        "param": [
          {
            "name": "exception",
            "type": "mixed"
          }
        ]
      }
    ]
  },
  {
    "name": "Statistic",
    "static": true,
    "description": "Static statistical functions.",
    "method": [
      {
        "name": "arithmeticMean",
        "description": "Calculates the arithmetic mean of a list of values.",
        "annotation": [
          "Weights may specify the contribution of each value to a weighted mean. If weights are specified and a value does not correspond to a weight, zero will be used as the weight of that particular value.",
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "weights",
            "type": "?object",
            "default": "unweighted"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "average",
        "description": "Calculates the average of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "averageDeviation",
        "description": "Calculates the average absolute deviation of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "center",
            "type": "?number",
            "default": "arithmetic mean of values"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "centralMoment",
        "description": "Calculates the central moment of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "order",
            "type": "number",
            "default": "2"
          },
          {
            "name": "center",
            "type": "?number",
            "default": "arithmetic mean of values"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "count",
        "description": "Counts the total number of values.",
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exponentialMovingAverage",
        "description": "Calculates the exponential moving average of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "exponent",
            "type": "?number",
            "value": "(default: 2/(N+1))"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "geometricMean",
        "description": "Calculates the geometric mean of a list of values.",
        "annotation": [
          "Weights may specify the contribution of each value to a weighted mean. If weights are specified and a value does not correspond to a weight, zero will be used as the weight of that particular value.",
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "weights",
            "type": "?object",
            "default": "unweighted"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "harmonicMean",
        "description": "Calculates the harmonic mean of a list of values.",
        "annotation": [
          "Weights may specify the contribution of each value to a weighted mean. If weights are specified and a value does not correspond to a weight, zero will be used as the weight of that particular value.",
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "weights",
            "type": "?object",
            "default": "unweighted"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "kurtosisPop",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "kurtosisSamp",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are less than four values"
          }
        ]
      },
      {
        "name": "linearMovingAverage",
        "description": "Calculates the linear weighted moving average of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "maximum",
        "description": "Measures the maximum of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "median",
        "description": "Measures the median of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "medianDeviation",
        "description": "Calculates the median absolute deviation of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "midrange",
        "description": "Measures the mid-range of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "minimum",
        "description": "Measures the minimum of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "mode",
        "description": "Measures the mode of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[number, ...]"
          }
        ]
      },
      {
        "name": "product",
        "description": "Calculates the product of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "quadraticMean",
        "description": "Calculates the quadratic mean of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "range",
        "description": "Measures the range of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of measurement."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "rawMoment",
        "description": "Calculates the raw moment of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          },
          {
            "name": "order",
            "type": "number",
            "default": "2"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "skewnessPop",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "skewnessSamp",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are less than three values"
          }
        ]
      },
      {
        "name": "standardDeviationPop",
        "description": "Calculates the population standard deviation of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "standardDeviationSamp",
        "description": "Calculates the sample standard deviation of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "float"
          },
          {
            "type": "null",
            "description": "if there are less than two values"
          }
        ]
      },
      {
        "name": "standardScore",
        "description": "Calculates the standard scores for a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[score, ...]"
          }
        ]
      },
      {
        "name": "sum",
        "description": "Sums up a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "variancePop",
        "description": "Calculates the population variance of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are no values"
          }
        ]
      },
      {
        "name": "varianceSamp",
        "description": "Calculates the sample variance of a list of values.",
        "annotation": [
          "Values are interpreted as numbers for the purpose of aggregation."
        ],
        "param": [
          {
            "name": "values",
            "type": "object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "number"
          },
          {
            "type": "null",
            "description": "if there are less than two values"
          }
        ]
      }
    ]
  },
  {
    "name": "String",
    "static": true,
    "description": "Static string related functions.",
    "method": [
      {
        "name": "byteAt",
        "description": "Returns the byte at a specific byte-based offset within a string.",
        "annotation": [
          "If the offset is negative, it positions at that many bytes from the end of the string.",
          "This function is equivalent to the \"[...]\" operator on strings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the offset is out of range"
          }
        ]
      },
      {
        "name": "byteCodeAt",
        "description": "Returns the US-ASCII code of the byte at a specific byte-based offset within a string.",
        "annotation": [
          "If the offset is negative, it positions at that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the offset is out of range"
          }
        ]
      },
      {
        "name": "byteIndexOf",
        "description": "Returns the byte-based index of the first occurrence of a specific substring within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "capitalize",
        "description": "Capitalizes the first character within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "capitalizeWords",
        "description": "Capitalizes every word within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "charAt",
        "description": "Returns the character at a specific character-based offset within a string.",
        "annotation": [
          "If the offset is negative, it positions at that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if the offset is out of range"
          }
        ]
      },
      {
        "name": "charCodeAt",
        "description": "Returns the UTF-8 code of the character at a specific character-based offset within a string.",
        "annotation": [
          "If the offset is negative, it positions at that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the offset is out of range"
          }
        ]
      },
      {
        "name": "chop",
        "description": "Chops a string into substrings of a specific character-based length, rejoined with a specific delimiter.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int",
            "default": "76"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\"\\r\\n\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "chopOnBytes",
        "description": "Chops a string into substrings of a specific byte-based length, rejoined with a specific delimiter.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int",
            "default": "76"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\"\\r\\n\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "compare",
        "description": "Compares two strings in a lexicographic manner.",
        "annotation": [
          "This function is similar to the \"<=>\" operator on strings, but not strictly equivalent, because it also compares numeric strings lexicographically."
        ],
        "param": [
          {
            "name": "string1",
            "type": "string"
          },
          {
            "name": "string2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int",
            "value": "+1",
            "description": "if the first string is greater than the second string"
          },
          {
            "type": "int",
            "value": "-1",
            "description": "if the first string is less than the second string"
          },
          {
            "type": "int",
            "value": "0",
            "description": "if both strings are equal"
          }
        ]
      },
      {
        "name": "compareNatural",
        "description": "Compares two strings in a natural and case-insensitive manner (US-ASCII only).",
        "param": [
          {
            "name": "string1",
            "type": "string"
          },
          {
            "name": "string2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int",
            "value": "+1",
            "description": "if the first string is greater than the second string"
          },
          {
            "type": "int",
            "value": "-1",
            "description": "if the first string is less than the second string"
          },
          {
            "type": "int",
            "value": "0",
            "description": "if both strings are equal"
          }
        ]
      },
      {
        "name": "concat",
        "description": "Concatenates specific strings and returns the combined end-to-end string.",
        "annotation": [
          "This function is equivalent to the \".\" operator."
        ],
        "param": [
          {
            "name": "strings",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "contains",
        "description": "Determines whether a string contains a specific substring.",
        "annotation": [
          "Strings always contain empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "containsInsensitive",
        "description": "Determines whether a string contains a specific substring in a case-insensitive manner (UTF-8).",
        "annotation": [
          "Strings always contain empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "convert",
        "description": "Converts the character encoding of a string from one character set into another.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "from",
            "type": "string",
            "default": "\"UTF-8\""
          },
          {
            "name": "to",
            "type": "string",
            "default": "\"UTF-8\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "countBytes",
        "description": "Counts the total number of bytes within a string.",
        "annotation": [
          "This function is equivalent to the \"count\" operator on strings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countChars",
        "description": "Counts the total number of characters within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countDistinctBytes",
        "description": "Counts the total number of distinct bytes within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countDistinctChars",
        "description": "Counts the total number of distinct characters within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countSubstring",
        "description": "Counts the total number of occurrences of a specific substring within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countUsedBytes",
        "description": "Counts the total number of occurrences for each byte within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-byte: count, ...]"
          }
        ]
      },
      {
        "name": "countUsedChars",
        "description": "Counts the total number of occurrences for each character within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[unique-character: count, ...]"
          }
        ]
      },
      {
        "name": "crc32",
        "description": "Generates the 32-bit cyclic redundancy checksum polynomial of a string as a signed integer.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "distanceBetween",
        "description": "Measures the Levenshtein distance between two strings.",
        "param": [
          {
            "name": "string1",
            "type": "string"
          },
          {
            "name": "string2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "endsWith",
        "description": "Determines whether a string ends with a specific substring.",
        "annotation": [
          "Strings always end with empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "endsWithInsensitive",
        "description": "Determines whether a string ends with a specific substring in a case-insensitive manner (UTF-8).",
        "annotation": [
          "Strings always end with empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "equals",
        "description": "Determines whether two strings are equal.",
        "annotation": [
          "This function is equivalent to the \"===\" operator on strings."
        ],
        "param": [
          {
            "name": "string1",
            "type": "string"
          },
          {
            "name": "string2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "equalsInsensitive",
        "description": "Determines whether two strings are equal in a case-insensitive manner (UTF-8).",
        "annotation": [
          "This function is equivalent to the \"==*\" operator on strings."
        ],
        "param": [
          {
            "name": "string1",
            "type": "string"
          },
          {
            "name": "string2",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "escapeC",
        "description": "Escapes all non-printable (plus backslash \"\\\") US-ASCII characters within a string using C-style (octal) escape sequences.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "foldCase",
        "description": "Converts a string according to length-preserving case-folding rules (UTF-8).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "format",
        "description": "Returns a formatted string with \"printf\"-compatible format specifiers (\"%...\") substituted with variadic arguments.",
        "annotation": [
          "Complex arguments are interpreted as strings for the purpose of formatting."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromByteCodes",
        "description": "Returns the string corresponding to an US-ASCII code sequence.",
        "annotation": [
          "This function is complementary to \"toByteCodes\"."
        ],
        "param": [
          {
            "name": "codes",
            "type": "object",
            "value": "[code, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromCharCodes",
        "description": "Returns the string corresponding to an UTF-8 code sequence.",
        "annotation": [
          "This function is complementary to \"toCharCodes\"."
        ],
        "param": [
          {
            "name": "codes",
            "type": "object",
            "value": "[code, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromHex",
        "annotation": [
          "This function is complementary to \"toHex\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "fromLatin1",
        "description": "Converts the character encoding of a string from single-byte ISO-8859-1 into multi-byte UTF-8.",
        "annotation": [
          "This function is complementary to \"toLatin1\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "hasByteIndex",
        "description": "Determines whether a string has a specific byte-based index.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasIndex",
        "description": "Determines whether a string has a specific character-based index.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "index",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "head",
        "description": "Returns the character-based head of a string, meaning only the first character.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "headOnBytes",
        "description": "Returns the byte-based head of a string, meaning only the first byte.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "indexOf",
        "description": "Returns the character-based index of the first occurrence of a specific substring within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "indexOfInsensitive",
        "description": "Returns the character-based index of the first occurrence of a specific substring within a string, searching in a case-insensitive manner (UTF-8).",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "insert",
        "description": "Inserts a specific substring into a string at a specific character-based offset.",
        "annotation": [
          "If the offset is negative, it inserts at that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "insertOnBytes",
        "description": "Inserts a specific substring into a string at a specific byte-based offset.",
        "annotation": [
          "If the offset is negative, it inserts at that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isBinaryDigits",
        "description": "Determines whether a string consists only of characters representing binary digits.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isDecimalDigits",
        "description": "Determines whether a string consists only of characters representing decimal digits.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isEmpty",
        "description": "Determines whether a string is empty, meaning it does not contain any bytes or characters.",
        "annotation": [
          "This function is equivalent to the \"empty\" operator on strings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isHexDigits",
        "description": "Determines whether a string consists only of characters representing hexadecimal digits.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isMarkedUTF8",
        "description": "Determines whether a string has an UTF-8 byte order mark (BOM).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isOctalDigits",
        "description": "Determines whether a string consists only of characters representing octal digits.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isPrintable",
        "description": "Determines whether a string represents a valid sequence of printable US-ASCII characters.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isSingleByte",
        "description": "Determines whether a string consists only of a single byte.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isSingleChar",
        "description": "Determines whether a string consists only of a single character.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidASCII",
        "description": "Determines whether a string represents a valid sequence of US-ASCII characters.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidUTF8",
        "description": "Determines whether a string represents a valid sequence of UTF-8 characters.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isWhiteSpace",
        "description": "Determines whether a string consists only of US-ASCII white space characters.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "lastByteIndexOf",
        "description": "Returns the byte-based index of the last occurrence of a specific substring within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "lastIndexOf",
        "description": "Returns the character-based index of the last occurrence of a specific substring within a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "lastIndexOfInsensitive",
        "description": "Returns the character-based index of the last occurrence of a specific substring within a string, searching in a case-insensitive manner (UTF-8).",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the substring is not found"
          }
        ]
      },
      {
        "name": "metaphone",
        "description": "Generates the metaphone key of a string.",
        "annotation": [
          "Metaphone keys have the property that words pronounced similarly produce the same metaphone key.",
          "This function is more accurate than \"soundex\" as it knows the basic rules of English pronunciation."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "normalizeLineBreaks",
        "description": "Normalizes line breaks by replacing all end-of-line markers (carriage return and/or line feed) with single line feeds.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "normalizeWhiteSpace",
        "description": "Normalizes white space by replacing all consecutive sequences of US-ASCII white space characters with single blank spaces.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "pad",
        "description": "Pads a string to a specific character-based length by repeatedly filling it with a specific padding string.",
        "annotation": [
          "If the length is positive, the string is padded right-sidedly at its end, if it is negative, the string is padded left-sidedly at its beginning."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int"
          },
          {
            "name": "padding",
            "type": "string",
            "default": "\" \""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "padOnBytes",
        "description": "Pads a string to a specific byte-based length by repeatedly filling it with a specific padding string.",
        "annotation": [
          "If the length is positive, the string is padded right-sidedly at its end, if it is negative, the string is padded left-sidedly at its beginning."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int"
          },
          {
            "name": "padding",
            "type": "string",
            "default": "\" \""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "partition",
        "description": "Partitions a string into isolated substrings of a specific character-based length.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substring, ...]"
          }
        ]
      },
      {
        "name": "partitionOnBytes",
        "description": "Partitions a string into isolated substrings of a specific byte-based length.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "length",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substring, ...]"
          }
        ]
      },
      {
        "name": "quote",
        "description": "Quotes a string by wrapping it with a specific delimiter.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\"'\""
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "repeat",
        "description": "Repeatedly concatenates a specific string to itself and returns the aligned end-to-end string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "count",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "replace",
        "description": "Replaces all occurrences of a specific substring within a string with a specific replacement.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          },
          {
            "name": "replacement",
            "type": "string"
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "replaceMultiple",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "replacements",
            "type": "object",
            "value": "[substring: replacement, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "reverse",
        "description": "Reverses the sequence of characters within a string.",
        "annotation": [
          "This function is its own inverse."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "reverseOnBytes",
        "description": "Reverses the sequence of bytes within a string.",
        "annotation": [
          "This function is its own inverse."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "scrub",
        "description": "Scrub ill-formed UTF-8 characters from a string by replacing those with placeholder question marks (\"?\").",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "slice",
        "description": "Slices a string by retrieving a specific character-based portion.",
        "annotation": [
          "If the offset is negative, it starts that many characters from the end of the string. If the length is null, every character from the offset until the end of the string is returned, if it is negative, it stops that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "sliceOnBytes",
        "description": "Slices a string by retrieving a specific byte-based portion.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string. If the length is null, every byte from the offset until the end of the string is returned, if it is negative, it stops that many bytes from the end of the string.",
          "This function is equivalent to the \"[..., ...]\" operator on strings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "soundex",
        "description": "Generates the 4-character soundex key of a string.",
        "annotation": [
          "Soundex keys have the property that words pronounced similarly produce the same soundex key.",
          "This function is less accurate than \"metaphone\" as the latter knows the basic rules of English pronunciation."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "splice",
        "description": "Extracts a specific character-based portion of a string and replaces it with a specific replacement string.",
        "annotation": [
          "If the offset is negative, it starts that many characters from the end of the string. If the length is null, every character from the offset until the end of the string is extracted, if it is negative, it stops that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          },
          {
            "name": "replacement",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "spliceOnBytes",
        "description": "Extracts a specific byte-based portion of a string and replaces it with a specific replacement string.",
        "annotation": [
          "If the offset is negative, it starts that many bytes from the end of the string. If the length is null, every byte from the offset until the end of the string is extracted, if it is negative, it stops that many bytes from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          },
          {
            "name": "replacement",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "split",
        "description": "Splits a string into isolated substrings on boundaries formed by a specific delimiter, whereas empty substrings are retained.",
        "annotation": [
          "This function returns an empty object for an empty string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\" \""
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substring, ...]"
          }
        ]
      },
      {
        "name": "splitNonEmpty",
        "description": "Splits a string into isolated substrings on boundaries formed by a specific delimiter, whereas empty substrings are discarded.",
        "annotation": [
          "This function returns an empty object for an empty string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "delimiter",
            "type": "string",
            "default": "\" \""
          },
          {
            "name": "limit",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[substring, ...]"
          }
        ]
      },
      {
        "name": "startsWith",
        "description": "Determines whether a string starts with a specific substring.",
        "annotation": [
          "Strings always start with empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "startsWithInsensitive",
        "description": "Determines whether a string starts with a specific substring in a case-insensitive manner (UTF-8).",
        "annotation": [
          "Strings always start with empty substrings."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "substring",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "tail",
        "description": "Returns the character-based tail of a string, meaning all characters except the first.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "tailOnBytes",
        "description": "Returns the byte-based tail of a string, meaning all bytes except the first.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toByteCodes",
        "description": "Returns the US-ASCII code sequence of all bytes within a string.",
        "annotation": [
          "This function is complementary to \"fromByteCodes\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[code, ...]"
          }
        ]
      },
      {
        "name": "toCharCodes",
        "description": "Returns the UTF-8 code sequence of all characters within a string.",
        "annotation": [
          "This function is complementary to \"fromCharCodes\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[code, ...]"
          }
        ]
      },
      {
        "name": "toHex",
        "annotation": [
          "This function is complementary to \"fromHex\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toLatin1",
        "description": "Converts the character encoding of a string from multi-byte UTF-8 to single-byte ISO-8859-1.",
        "annotation": [
          "This function is complementary to \"fromLatin1\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toLower",
        "description": "Converts a string to lower case (UTF-8).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toLowerASCII",
        "description": "Converts a string to lower case (US-ASCII only).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toUpper",
        "description": "Converts a string to upper case (UTF-8).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toUpperASCII",
        "description": "Converts a string to upper case (US-ASCII only).",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "trim",
        "description": "Trims a string by stripping all US-ASCII white space characters from its beginning and end.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "trimLeft",
        "description": "Trims a string left-sidedly by stripping all US-ASCII white space characters from its beginning.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "trimRight",
        "description": "Trims a string right-sidedly by stripping all US-ASCII white space characters from its end.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "truncate",
        "description": "Truncates a string to a specific byte-based length, where half-width characters count as 1, and full-width characters count as 2.",
        "annotation": [
          "If the offset is negative, it starts that many characters from the end of the string."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "offset",
            "type": "int"
          },
          {
            "name": "length",
            "type": "int",
            "default": "255"
          },
          {
            "name": "marker",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "unescapeC",
        "description": "Resolve all C-style escape sequences in a string.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "System",
    "static": true,
    "description": "Static system related constants and functions.",
    "const": [
      {
        "name": "OS",
        "type": "string",
        "description": "Operating system identifier"
      },
      {
        "name": "PHPVERSION",
        "type": "string",
        "description": "PHP version number"
      },
      {
        "name": "SAPI",
        "type": "string",
        "description": "Server API identifier"
      }
    ],
    "method": [
      {
        "name": "getCurrentMemoryUsage",
        "description": "Gets the current memory usage of the underlying runtime environment in number of bytes.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getHost",
        "description": "Gets the host name of the system.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getMachine",
        "description": "Gets the machine architecture of the system.",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getMonotonicTime",
        "description": "Gets the system's monotonic clock in ticks, representing elapsed time since an unspecified starting point.",
        "annotation": [
          "The monotonic clock is independent of the real clock and increments continuously without being affected by system date and time adjustments."
        ],
        "return": [
          {
            "type": "int"
          },
          {
            "type": "float",
            "description": "on 32-bit systems"
          }
        ]
      },
      {
        "name": "getPeakMemoryUsage",
        "description": "Gets the peak memory usage of the underlying runtime environment in number of bytes.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getProcessID",
        "description": "Gets the process ID of the underlying runtime environment.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "listCommandLineArguments",
        "description": "Lists all command line arguments passed to the underlying runtime environment.",
        "return": [
          {
            "type": "object",
            "value": "[argument, ...]"
          }
        ]
      },
      {
        "name": "sleep",
        "description": "Delays execution for a specific duration in number of seconds.",
        "annotation": [
          "The duration may include nanoseconds in the fractional part."
        ],
        "param": [
          {
            "name": "duration",
            "type": "number",
            "default": "1"
          }
        ]
      }
    ]
  },
  {
    "name": "URI",
    "static": true,
    "description": "Static URI related functions.",
    "method": [
      {
        "name": "createDataURI",
        "description": "Creates a data URI according to RFC 2397.",
        "param": [
          {
            "name": "string",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string",
            "default": "\"text/plain\""
          },
          {
            "name": "charset",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createQuery",
        "description": "Creates the URI query component out of specific attribute name and value pairs according to RFC 3986.",
        "param": [
          {
            "name": "attributes",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "decode",
        "description": "Decodes a string according to RFC 3986 by replacing sequences incipient with a percent sign (\"%\") followed by a 2-character hexadecimal number with their applicable characters.",
        "annotation": [
          "This function is complementary to \"encode\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "encode",
        "description": "Encodes a string according to RFC 3986 by replacing non-alphanumeric characters except \"-\", \"_\", \".\" and \"~\" with a percent sign (\"%\") followed by a 2-character hexadecimal number.",
        "annotation": [
          "This function is complementary to \"decode\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getAuthority",
        "description": "Gets the authority component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getFragment",
        "description": "Gets the fragment component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getHierarchy",
        "description": "Gets the hierarchy component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getHost",
        "description": "Gets the host name component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPassword",
        "description": "Gets the password component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPath",
        "description": "Gets the path name component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPort",
        "description": "Gets the port number component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getQuery",
        "description": "Gets the query component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getScheme",
        "description": "Gets the scheme component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getUser",
        "description": "Gets the username component of an URI.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "isAbsolute",
        "description": "Determines whether an URI is absolute, meaning it has a scheme component.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isFile",
        "description": "Determines whether an URI is of the file URI scheme.",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValid",
        "description": "Determines whether an URI is valid.",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "normalize",
        "description": "Normalizes an URI to its canonicalized representation according to RFC 3986 and the comparison rules of RFC 2616.",
        "annotation": [
          "Converts scheme and host components to lower case, omits default port for HTTP (80) and HTTPS (443), capitalizes hexadecimal letters in percent-encoded sequences, and removes dot-segments from path component."
        ],
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "parse",
        "param": [
          {
            "name": "uri",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[\"scheme\": ..., \"user\": ..., \"password\": ..., \"host\": ..., \"port\": ..., \"path\": ..., \"query\": ..., \"fragment\": ...]"
          }
        ]
      },
      {
        "name": "parseQuery",
        "param": [
          {
            "name": "query",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      }
    ]
  },
  {
    "name": "Var",
    "static": true,
    "description": "Static variable related functions.",
    "method": [
      {
        "name": "clone",
        "description": "Clones the value by creating a shallow copy.",
        "annotation": [
          "This function is equivalent to the \"clone\" operator."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "cloneDeep",
        "description": "Clones the value by creating a deep copy.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "compare",
        "description": "Compares two values.",
        "annotation": [
          "This function is equivalent to the \"<=>\" operator."
        ],
        "param": [
          {
            "name": "value1",
            "type": "mixed"
          },
          {
            "name": "value2",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int",
            "value": "+1",
            "description": "if the first value is greater than the second value"
          },
          {
            "type": "int",
            "value": "-1",
            "description": "if the first value is less than the second value"
          },
          {
            "type": "int",
            "value": "0",
            "description": "if both values are equal"
          }
        ]
      },
      {
        "name": "count",
        "description": "Counts the total number of intrinsic constituents of a value.",
        "annotation": [
          "This function is equivalent to the \"count\" operator."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "countGlobalVariables",
        "description": "Counts the total number of global variables.",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "exists",
        "description": "Determines whether a value exists, meaning is not null.",
        "annotation": [
          "This function is equivalent to the \"exists\" operator."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "fromJSON",
        "description": "Returns the value corresponding to a JavaScript Object Notation (JSON) representation according to RFC 4627.",
        "annotation": [
          "This function is complementary to \"toJSON\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "fromSerializedPHP",
        "description": "Returns the value corresponding to a serialized PHP representation.",
        "annotation": [
          "This function is complementary to \"toSerializedPHP\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "isBool",
        "description": "Determines whether a value is of type \"bool\", meaning either true or false.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isComplex",
        "description": "Determines whether a value is of a complex type.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isEmpty",
        "description": "Determines whether a value is empty, meaning either null, an empty string or an empty object.",
        "annotation": [
          "This function is equivalent to the \"empty\" operator."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isFloat",
        "description": "Determines whether a value is of type \"float\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isFunction",
        "description": "Determines whether a value is of type \"function\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isInt",
        "description": "Determines whether a value is of type \"int\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNull",
        "description": "Determines whether a value is null.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNumber",
        "description": "Determines whether a value is a number, meaning of type \"int\" or \"float\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNumeric",
        "description": "Determines whether a value is numeric, meaning a number or the string representation thereof.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isObject",
        "description": "Determines whether a value is of type \"object\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isScalar",
        "description": "Determines whether a value is of a scalar type, meaning all primitive non-composite types.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isString",
        "description": "Determines whether a value is of type \"string\".",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isValidJSON",
        "description": "Determines whether a string represents a valid JavaScript Object Notation (JSON) representation according to RFC 4627.",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listGlobalVariableNames",
        "description": "Lists all variable names of global scope.",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listGlobalVariables",
        "description": "Lists all variables of global scope.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "pack",
        "description": "Packs variadic arguments into binary data according to a specific Perl/PHP-compatible format.",
        "annotation": [
          "Complex arguments are interpreted as strings for the purpose of packing.",
          "This function is complementary to \"unpack\"."
        ],
        "param": [
          {
            "name": "format",
            "type": "string"
          },
          {
            "name": "arguments",
            "type": "variadic"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toJSON",
        "description": "Returns the JavaScript Object Notation (JSON) representation of a value according to RFC 4627.",
        "annotation": [
          "This function is complementary to \"fromJSON\"."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toPrettyJSON",
        "description": "Returns the JavaScript Object Notation (JSON) representation of a value according to RFC 4627 in human-readable form.",
        "annotation": [
          "This function is complementary to \"fromJSON\"."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toSerializedPHP",
        "description": "Returns the serialized PHP representation of a value.",
        "annotation": [
          "This function is complementary to \"fromSerializedPHP\"."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toSource",
        "description": "Returns the Zymba source-code literal representation of a value.",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "typeOf",
        "description": "Returns the type of a value.",
        "annotation": [
          "This function is equivalent to the \"typeof\" operator."
        ],
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "unpack",
        "description": "Unpacks values from binary data according to a specific Perl/PHP-compatible format.",
        "annotation": [
          "This function is complementary to \"pack\"."
        ],
        "param": [
          {
            "name": "format",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object",
            "value": "[value, ...]"
          }
        ]
      }
    ]
  },
  {
    "name": "XML",
    "static": true,
    "description": "Static XML related functions.",
    "method": [
      {
        "name": "createFromTree",
        "param": [
          {
            "name": "tree",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "escape",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "parse",
        "param": [
          {
            "name": "document",
            "type": "string"
          },
          {
            "name": "callback_open",
            "type": "?function"
          },
          {
            "name": "callback_close",
            "type": "?function"
          },
          {
            "name": "callback_cdata",
            "type": "?function"
          },
          {
            "name": "bind",
            "type": "?object"
          },
          {
            "name": "preservecase",
            "type": "bool",
            "default": "false"
          }
        ]
      },
      {
        "name": "parseToTree",
        "param": [
          {
            "name": "document",
            "type": "string"
          },
          {
            "name": "preservecase",
            "type": "bool",
            "default": "false"
          }
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "unescape",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "ZIP",
    "static": true,
    "description": "Static ZIP related prototypes."
  },
  {
    "name": "ZIP.Archive",
    "static": false,
    "extend": "Base",
    "description": "ZIP archive prototype.",
    "const": [
      {
        "name": "COMPRESS_DEFAULT",
        "type": "int",
        "description": "Default compression method (Deflate or Store)"
      },
      {
        "name": "COMPRESS_STORE",
        "type": "int",
        "description": "Raw store method, no compression"
      },
      {
        "name": "COMPRESS_SHRINK",
        "type": "int",
        "description": "Shrink (LZW) compression method"
      },
      {
        "name": "COMPRESS_REDUCE1",
        "type": "int",
        "description": "Reduce level 1 compression method"
      },
      {
        "name": "COMPRESS_REDUCE2",
        "type": "int",
        "description": "Reduce level 2 compression method"
      },
      {
        "name": "COMPRESS_REDUCE3",
        "type": "int",
        "description": "Reduce level 3 compression method"
      },
      {
        "name": "COMPRESS_REDUCE4",
        "type": "int",
        "description": "Reduce level 4 compression method"
      },
      {
        "name": "COMPRESS_IMPLODE",
        "type": "int",
        "description": "Implode compression method"
      },
      {
        "name": "COMPRESS_DEFLATE",
        "type": "int",
        "description": "Deflate compression method"
      },
      {
        "name": "COMPRESS_DEFLATE64",
        "type": "int",
        "description": "Enhanced Deflate (Deflate64) compression method"
      },
      {
        "name": "COMPRESS_PKWARE",
        "type": "int",
        "description": "PKWARE Implode compression method"
      },
      {
        "name": "COMPRESS_BZIP2",
        "type": "int",
        "description": "BZip2 compression method"
      },
      {
        "name": "COMPRESS_LZMA",
        "type": "int",
        "description": "LZMA compression method"
      },
      {
        "name": "COMPRESS_TERSE",
        "type": "int",
        "description": "TERSE compression method"
      },
      {
        "name": "COMPRESS_LZ77",
        "type": "int",
        "description": "LZ77 compression method"
      },
      {
        "name": "COMPRESS_LZMA",
        "type": "int",
        "description": "LZMA2 compression method"
      },
      {
        "name": "COMPRESS_ZSTD",
        "type": "int",
        "description": "Zstandard compression method"
      },
      {
        "name": "COMPRESS_MP3",
        "type": "int",
        "description": "MP3 compression method"
      },
      {
        "name": "COMPRESS_XZ",
        "type": "int",
        "description": "XZ compression method"
      },
      {
        "name": "COMPRESS_JPEG",
        "type": "int",
        "description": "JPEG compression method"
      },
      {
        "name": "COMPRESS_WAVPACK",
        "type": "int",
        "description": "WavPack compression method"
      },
      {
        "name": "COMPRESS_PPMD",
        "type": "int",
        "description": "PPMd compression method"
      },
      {
        "name": "ENCRYPT_NONE",
        "type": "int",
        "description": "No encryption"
      },
      {
        "name": "ENCRYPT_PKWARE",
        "type": "int",
        "description": "Traditional PKWARE encryption method"
      },
      {
        "name": "ENCRYPT_AES128",
        "type": "int",
        "description": "AES-128 encryption method"
      },
      {
        "name": "ENCRYPT_AES128",
        "type": "int",
        "description": "AES-192 encryption method"
      },
      {
        "name": "ENCRYPT_AES128",
        "type": "int",
        "description": "AES-256 encryption method"
      },
      {
        "name": "ENCRYPT_UNKNOWN",
        "type": "int",
        "description": "Unknown encryption method"
      },
      {
        "name": "MODE_READ",
        "type": "int",
        "description": "Archive read mode"
      },
      {
        "name": "MODE_WRITE",
        "type": "int",
        "description": "Archive write mode, implies read mode"
      },
      {
        "name": "MODE_CREATE",
        "type": "int",
        "description": "Archive create mode, implies write mode"
      },
      {
        "name": "MODE_TRUNCATE",
        "type": "int",
        "description": "Archive truncate mode, implies write mode"
      },
      {
        "name": "MODE_OVERWRITE",
        "type": "int",
        "description": "Archive overwrite mode, same as create plus truncate mode"
      }
    ],
    "method": [
      {
        "name": "construct",
        "description": "Opens a ZIP archive in a specific access mode (see MODE_* constants).",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "mode",
            "type": "int",
            "default": "MODE_READ | MODE_WRITE | MODE_CREATE"
          }
        ]
      },
      {
        "name": "addDirectory",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "prefix",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "addFile",
        "param": [
          {
            "name": "path",
            "type": "string"
          },
          {
            "name": "name",
            "type": "string",
            "default": "derived from path"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "close",
        "description": "Closes this archive and frees its associated resources."
      },
      {
        "name": "countEntries",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "crc32",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "createDirectory",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "delete",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "exists",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "exit",
        "description": "Closes this archive, rolls it back on failure and frees its associated resources for the purpose of contextualization.",
        "param": [
          {
            "name": "exception",
            "type": "mixed"
          }
        ]
      },
      {
        "name": "extract",
        "param": [
          {
            "name": "entries",
            "type": "object",
            "value": "[name, ...]"
          },
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "extractAll",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "getComment",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getCompression",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getLastModified",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getSize",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getSizeRaw",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "listEntries",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "move",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "target",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "read",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "length",
            "type": "?int",
            "default": "maximum length"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readRaw",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "restore",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "rollback",
        "description": "Rolls back this archive by discarding all changes.",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "selectStream",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "@IO.Stream"
          }
        ]
      },
      {
        "name": "setComment",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "comment",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setCompression",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "method",
            "type": "int",
            "default": "COMPRESS_DEFAULT"
          },
          {
            "name": "flags",
            "type": "int"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setEncryption",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "method",
            "type": "int",
            "default": "ENCRYPT_NONE"
          },
          {
            "name": "password",
            "type": "?string",
            "default": "archive password"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setLastModified",
        "annotation": [
          "Timestamps are based on Unix time, defined as the number of non-leap seconds since midnight UTC on January 1, 1970."
        ],
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setPassword",
        "param": [
          {
            "name": "password",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "write",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZLIB",
    "static": true,
    "description": "Static ZLIB related functions.",
    "method": [
      {
        "name": "deflate",
        "description": "Deflates a string using ZLIB compression according to RFC 1950.",
        "annotation": [
          "This function is complementary to \"inflate\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "deflateRaw",
        "description": "Deflates a string using DEFLATE compression in raw format according to RFC 1951.",
        "annotation": [
          "This function is complementary to \"inflateRaw\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "gunzip",
        "description": "Unzips a string using GZIP decompression according to RFC 1952.",
        "annotation": [
          "This function is complementary to \"gzip\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "gzip",
        "description": "Zips a string using GZIP compression according to RFC 1952.",
        "annotation": [
          "This function is complementary to \"gunzip\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "inflate",
        "description": "Inflates a string using ZLIB decompression according to RFC 1950.",
        "annotation": [
          "This function is complementary to \"deflate\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "inflateRaw",
        "description": "Inflates a string using DEFLATE decompression in raw format according to RFC 1951.",
        "annotation": [
          "This function is complementary to \"deflateRaw\"."
        ],
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS",
    "static": true,
    "const": [
      {
        "name": "BASEURL",
        "type": "string",
        "description": "ZeyOS base URL"
      },
      {
        "name": "EXTURL",
        "type": "string",
        "description": "ZeyOS external URL"
      },
      {
        "name": "LICENSEKEY",
        "type": "string",
        "description": "ZeyOS license key"
      },
      {
        "name": "VERSION",
        "type": "int",
        "description": "ZeyOS version number"
      }
    ],
    "method": [
      {
        "name": "authenticateUser",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "password",
            "type": "string"
          },
          {
            "name": "otp",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "@ZeyOS.ObjectUser"
          },
          {
            "type": "null",
            "description": "if authentication failed"
          }
        ]
      },
      {
        "name": "createShareToken",
        "param": [
          {
            "name": "entity",
            "type": "string"
          },
          {
            "name": "id",
            "type": "int"
          },
          {
            "name": "expdate",
            "type": "?int",
            "default": "100 days from now"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "createZUGFERD",
        "param": [
          {
            "name": "pdf",
            "type": "string"
          },
          {
            "name": "xml",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "extractZUGFERD",
        "param": [
          {
            "name": "pdf",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          },
          {
            "type": "null",
            "description": "if there is no embedded XML"
          }
        ]
      },
      {
        "name": "getTempPath",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "initializeItems",
        "param": [
          {
            "name": "items",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "listSessionVariables",
        "description": "Lists all session variables.",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "log",
        "param": [
          {
            "name": "message",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string"
          },
          {
            "name": "severity",
            "type": "string"
          }
        ]
      },
      {
        "name": "queueMail",
        "param": [
          {
            "name": "message",
            "type": "string"
          },
          {
            "name": "mailserver",
            "type": "?int"
          },
          {
            "name": "senddate",
            "type": "?int"
          }
        ],
        "return": [
          {
            "type": "?int"
          }
        ]
      },
      {
        "name": "readConfig",
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "resetCron",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "selectDatabase",
        "return": [
          {
            "type": "@SQL.PostgreSQL"
          }
        ]
      },
      {
        "name": "selectSession",
        "return": [
          {
            "type": "@ZeyOS.ObjectUser"
          },
          {
            "type": "null",
            "description": "if there is no session"
          }
        ]
      },
      {
        "name": "sendFile",
        "description": "Sends the content of a file as sole output on exit (if possible).",
        "param": [
          {
            "name": "path",
            "type": "string"
          }
        ]
      },
      {
        "name": "writeConfig",
        "param": [
          {
            "name": "config",
            "type": "object"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.AuditIterator",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "timestamp",
            "type": "?int",
            "default": "now"
          }
        ]
      },
      {
        "name": "close"
      },
      {
        "name": "exit"
      },
      {
        "name": "hasMore",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "next",
        "return": [
          {
            "type": "object"
          },
          {
            "type": "null",
            "description": "if there are no more transactions"
          }
        ]
      },
      {
        "name": "reset",
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.BinFile",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "id",
            "type": "?int",
            "default": "new"
          }
        ]
      },
      {
        "name": "exists",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "getID",
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the file does not exist"
          }
        ]
      },
      {
        "name": "read",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readOut",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "write",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.ExtData",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "entity",
            "type": "string"
          },
          {
            "name": "id",
            "type": "int"
          }
        ]
      },
      {
        "name": "clear",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "countFields",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getEntity",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getField",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "?string"
          }
        ]
      },
      {
        "name": "getID",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "hasField",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listFieldNames",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listFields",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "removeFields",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setField",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "?string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setFields",
        "param": [
          {
            "name": "fields",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.KeyAuth",
    "static": true,
    "method": [
      {
        "name": "create",
        "param": [
          {
            "name": "key",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "verify",
        "param": [
          {
            "name": "key",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          },
          {
            "type": "null",
            "description": "if there is no proper authorization header"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.NumFormat",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "getFormat",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getName",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getNumber",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "incrementCounter",
        "param": [
          {
            "name": "offset",
            "type": "int",
            "default": "1"
          }
        ],
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "nextNumber",
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.Object",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "entity",
            "type": "string"
          },
          {
            "name": "id",
            "type": "?int",
            "default": "new"
          }
        ]
      },
      {
        "name": "addTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "canDelete",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "clear",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "delete",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "erase",
        "param": [
          {
            "name": "callback",
            "type": "?function",
            "default": "no callback"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "eraseRaw",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "exists",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "getEntity",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getField",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "?string"
          }
        ]
      },
      {
        "name": "getFieldArray",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "?object"
          }
        ]
      },
      {
        "name": "getFieldJSON",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "?object"
          }
        ]
      },
      {
        "name": "getID",
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if the object is not persistent"
          }
        ]
      },
      {
        "name": "hasAccess",
        "param": [
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasField",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listExtData",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listFieldNames",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "listFields",
        "return": [
          {
            "type": "object",
            "value": "[name: value, ...]"
          }
        ]
      },
      {
        "name": "listTags",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "readBinFile",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "reload",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "removeFields",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "removeTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "resetTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "save",
        "param": [
          {
            "name": "callback",
            "type": "?function",
            "default": "no callback"
          },
          {
            "name": "extdata",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "tags",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "saveRaw",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "selectExtData",
        "return": [
          {
            "type": "@ZeyOS.ExtData"
          },
          {
            "type": "null",
            "description": "if the object is not persistent"
          }
        ]
      },
      {
        "name": "selectTags",
        "return": [
          {
            "type": "@ZeyOS.Tags"
          },
          {
            "type": "null",
            "description": "if the object is not persistent"
          }
        ]
      },
      {
        "name": "setExtData",
        "param": [
          {
            "name": "fields",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setField",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "?string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setFieldArray",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "array",
            "type": "?object",
            "value": "[value, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setFieldEncrypted",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "value",
            "type": "?string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setFieldJSON",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "array",
            "type": "?object"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setFields",
        "param": [
          {
            "name": "fields",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "writeBinFile",
        "param": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "data",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.ObjectTransaction",
    "static": false,
    "extend": "ZeyOS.Object",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "id",
            "type": "?int",
            "default": "new"
          }
        ]
      },
      {
        "name": "book",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "calculateTaxes",
        "return": [
          {
            "type": "object",
            "value": "[[taxrate: ..., totalnet: ..., totalgross: ..., tax: ...], ...]"
          }
        ]
      },
      {
        "name": "calculateTotals",
        "return": [
          {
            "type": "object",
            "value": "[discount: ..., netamount: ..., tax:: ..., costs: ..., weight: ...]"
          }
        ]
      },
      {
        "name": "canCancel",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "cancel",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "canClose",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "close",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "fromEinvoice",
        "param": [
          {
            "name": "document",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "fromXML",
        "param": [
          {
            "name": "xml",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "getBalance",
        "return": [
          {
            "type": "float"
          }
        ]
      },
      {
        "name": "getItems",
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "isBilling",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isProcurement",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isProduction",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "process",
        "param": [
          {
            "name": "fields",
            "type": "object",
            "value": "[name: value, ...]"
          },
          {
            "name": "serials",
            "type": "object",
            "value": "[serialnum, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "setItems",
        "param": [
          {
            "name": "items",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "toEinvoice",
        "param": [
          {
            "name": "extra",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toXML",
        "param": [
          {
            "name": "format",
            "type": "string",
            "default": "\"CII\""
          },
          {
            "name": "context",
            "type": "string"
          },
          {
            "name": "extra",
            "type": "object",
            "value": "[name: value, ...]"
          }
        ],
        "return": [
          {
            "type": "string"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.ObjectUser",
    "static": false,
    "extend": "ZeyOS.Object",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "id",
            "type": "?int",
            "default": "new"
          }
        ]
      },
      {
        "name": "getLang",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getLastLogin",
        "return": [
          {
            "type": "int"
          },
          {
            "type": "null",
            "description": "if there was no login yet"
          }
        ]
      },
      {
        "name": "getSettings",
        "return": [
          {
            "type": "object"
          }
        ]
      },
      {
        "name": "hasAccessTo",
        "param": [
          {
            "name": "object",
            "type": "@ZeyOS.Object"
          },
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasPermission",
        "param": [
          {
            "name": "identifier",
            "type": "string"
          },
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasPermissionApp",
        "param": [
          {
            "name": "id",
            "type": "int"
          },
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasPermissionFork",
        "param": [
          {
            "name": "id",
            "type": "int"
          },
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "inGroup",
        "param": [
          {
            "name": "id",
            "type": "int"
          },
          {
            "name": "writable",
            "type": "bool"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isAdmin",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isApiOnly",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "isNoPublic",
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listGroups",
        "return": [
          {
            "type": "object",
            "value": "[id: writable, ...]"
          }
        ]
      },
      {
        "name": "listPermissions",
        "return": [
          {
            "type": "object",
            "value": "[identifier: writable, ...]"
          }
        ]
      },
      {
        "name": "listPermittedApps",
        "return": [
          {
            "type": "object",
            "value": "[id: writable, ...]"
          }
        ]
      },
      {
        "name": "listPermittedForks",
        "return": [
          {
            "type": "object",
            "value": "[id: writable, ...]"
          }
        ]
      },
      {
        "name": "setPassword",
        "param": [
          {
            "name": "password",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "setSettings",
        "param": [
          {
            "name": "settings",
            "type": "object"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "verifyPassword",
        "param": [
          {
            "name": "password",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.Tags",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "entity",
            "type": "string"
          },
          {
            "name": "id",
            "type": "int"
          }
        ]
      },
      {
        "name": "addTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "clear",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "countTags",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "getEntity",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getID",
        "return": [
          {
            "type": "int"
          }
        ]
      },
      {
        "name": "hasAllTags",
        "annotation": [
          "This function returns true for an empty names list (vacuous truth)."
        ],
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasAnyTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "hasTag",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "bool"
          }
        ]
      },
      {
        "name": "listTags",
        "return": [
          {
            "type": "object",
            "value": "[name, ...]"
          }
        ]
      },
      {
        "name": "removeTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "resetTags",
        "param": [
          {
            "name": "names",
            "type": "object",
            "value": "[name, ...]"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.TempFile",
    "static": false,
    "extend": "Base",
    "method": [
      {
        "name": "construct",
        "param": [
          {
            "name": "name",
            "type": "string"
          }
        ]
      },
      {
        "name": "delete",
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "getName",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "getPath",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "read",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "readJSON",
        "return": [
          {
            "type": "mixed"
          }
        ]
      },
      {
        "name": "reserve",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "toString",
        "return": [
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "write",
        "param": [
          {
            "name": "string",
            "type": "string"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      },
      {
        "name": "writeJSON",
        "param": [
          {
            "name": "value",
            "type": "mixed"
          }
        ],
        "return": [
          {
            "type": "this"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.TransactionContext",
    "static": false,
    "extend": "Base",
    "description": "ZeyOS transaction context prototype.",
    "method": [
      {
        "name": "construct"
      },
      {
        "name": "enter"
      },
      {
        "name": "exit",
        "param": [
          {
            "name": "exception",
            "type": "mixed"
          }
        ]
      }
    ]
  },
  {
    "name": "ZeyOS.Warning",
    "static": false,
    "extend": "Exception"
  }
]