# Zymba authoritative reference — LLM working set

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirror: /__doc/zymbaref.json; SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915
Indexes: /ai/zymba/namespaces.json and /ai/zymba/symbols.json
Declared namespaces, methods and constants only; inherited members are not duplicated. Signatures are display aids, not executable call syntax or runtime validation. Missing metadata remains unknown.
This working set contains reference declarations, not the deferred Zymba guide. It does not compile or execute code.

# Zymba reference: Array

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/0
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Array

Source pointer: /0

```json
{
  "name": "Array",
  "static": true,
  "description": "Static array related prototypes and functions."
}
```

## method: Array.clear

Source pointer: /0/method/0

```text
clear(object $array): object
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.combine

Source pointer: /0/method/1

```text
combine(object $keys, object $values): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.complementByKeys

Source pointer: /0/method/2

```text
complementByKeys(object $array, variadic $arrays): object
```

```json
{
  "name": "complementByKeys",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "arrays",
      "type": "variadic",
      "value": "[key: value, ...]"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[retained-original-key: original-value, ...]"
    }
  ]
}
```

## method: Array.complementByValues

Source pointer: /0/method/3

```text
complementByValues(object $array, variadic $arrays): object
```

```json
{
  "name": "complementByValues",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "arrays",
      "type": "variadic",
      "value": "[key: value, ...]"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[original-key: retained-original-value, ...]"
    }
  ]
}
```

## method: Array.concat

Source pointer: /0/method/4

```text
concat(object $array, variadic $arrays): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.contains

Source pointer: /0/method/5

```text
contains(object $array, variadic $arrays): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.count

Source pointer: /0/method/6

```text
count(object $array): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.countDistinctValues

Source pointer: /0/method/7

```text
countDistinctValues(object $array): int
```

```json
{
  "name": "countDistinctValues",
  "description": "Counts the total number of distinct values within an array.",
  "param": [
    {
      "name": "array",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Array.countUsedValues

Source pointer: /0/method/8

```text
countUsedValues(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.countValue

Source pointer: /0/method/9

```text
countValue(object $array, mixed $value): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.createAssociative

Source pointer: /0/method/10

```text
createAssociative(object $keys, mixed $value): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.createIndex

Source pointer: /0/method/11

```text
createIndex(int $length, mixed $value): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.createRange

Source pointer: /0/method/12

```text
createRange(number $from, number $to, number $step): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.equals

Source pointer: /0/method/13

```text
equals(object $array1, object $array2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.equalsInOrder

Source pointer: /0/method/14

```text
equalsInOrder(object $array1, object $array2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.every

Source pointer: /0/method/15

```text
every(object $array, function $callback, ?object $bind): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.filter

Source pointer: /0/method/16

```text
filter(object $array, function $callback, ?object $bind): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.findKey

Source pointer: /0/method/17

```text
findKey(object $array, function $callback, ?object $bind): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.findValue

Source pointer: /0/method/18

```text
findValue(object $array, function $callback, ?object $bind): mixed | null
```

```json
{
  "name": "findValue",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "bind",
      "type": "?object"
    }
  ],
  "return": [
    {
      "type": "mixed"
    },
    {
      "type": "null",
      "description": "if not found"
    }
  ]
}
```

## method: Array.firstKey

Source pointer: /0/method/19

```text
firstKey(object $array): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.firstValue

Source pointer: /0/method/20

```text
firstValue(object $array): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.flip

Source pointer: /0/method/21

```text
flip(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.forEach

Source pointer: /0/method/22

```text
forEach(object $array, function $callback, ?object $bind)
```

```json
{
  "name": "forEach",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "bind",
      "type": "?object"
    }
  ]
}
```

## method: Array.fromCSV

Source pointer: /0/method/23

```text
fromCSV(string $string, string $delimiter): object
```

```json
{
  "name": "fromCSV",
  "annotation": [
    "This function is complementary to \"toCSV\"."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "delimiter",
      "type": "string",
      "default": "\";\""
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[[value, ...], ...]"
    }
  ]
}
```

## method: Array.getUniformType

Source pointer: /0/method/24

```text
getUniformType(object $array): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasAllKeys

Source pointer: /0/method/25

```text
hasAllKeys(object $array, object $keys): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasAllValues

Source pointer: /0/method/26

```text
hasAllValues(object $array, object $values): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasAnyKeys

Source pointer: /0/method/27

```text
hasAnyKeys(object $array, object $keys): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasAnyValues

Source pointer: /0/method/28

```text
hasAnyValues(object $array, object $values): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasKey

Source pointer: /0/method/29

```text
hasKey(object $array, string $key): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasSameKeys

Source pointer: /0/method/30

```text
hasSameKeys(object $array1, object $array2): bool
```

```json
{
  "name": "hasSameKeys",
  "description": "Determines whether two arrays have the same keys.",
  "param": [
    {
      "name": "array1",
      "type": "object"
    },
    {
      "name": "array2",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.hasSameKeysInOrder

Source pointer: /0/method/31

```text
hasSameKeysInOrder(object $array1, object $array2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.hasSameValues

Source pointer: /0/method/32

```text
hasSameValues(object $array1, object $array2): bool
```

```json
{
  "name": "hasSameValues",
  "description": "Determines whether two arrays have the same values.",
  "param": [
    {
      "name": "array1",
      "type": "object"
    },
    {
      "name": "array2",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.hasValue

Source pointer: /0/method/33

```text
hasValue(object $array, mixed $value): bool
```

```json
{
  "name": "hasValue",
  "description": "Determines whether an array has a specific value.",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.head

Source pointer: /0/method/34

```text
head(object $array): object
```

```json
{
  "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]"
    }
  ]
}
```

## method: Array.insert

Source pointer: /0/method/35

```text
insert(object $array, object $values, int $offset): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.intersectByKeys

Source pointer: /0/method/36

```text
intersectByKeys(object $array, variadic $arrays): object
```

```json
{
  "name": "intersectByKeys",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "arrays",
      "type": "variadic",
      "value": "[key: value, ...]"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[retained-original-key: original-value, ...]"
    }
  ]
}
```

## method: Array.intersectByValues

Source pointer: /0/method/37

```text
intersectByValues(object $array, variadic $arrays): object
```

```json
{
  "name": "intersectByValues",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "arrays",
      "type": "variadic",
      "value": "[key: value, ...]"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[original-key: retained-original-value, ...]"
    }
  ]
}
```

## method: Array.isEmpty

Source pointer: /0/method/38

```text
isEmpty(object $array): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.isIndexed

Source pointer: /0/method/39

```text
isIndexed(object $array): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.isMultidimensional

Source pointer: /0/method/40

```text
isMultidimensional(object $array): bool
```

```json
{
  "name": "isMultidimensional",
  "description": "Determines whether an array is multidimensional, meaning it contains object values.",
  "param": [
    {
      "name": "array",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.joinKeys

Source pointer: /0/method/41

```text
joinKeys(object $array, string $delimiter): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.joinNonEmptyValues

Source pointer: /0/method/42

```text
joinNonEmptyValues(object $array, string $delimiter, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.joinValues

Source pointer: /0/method/43

```text
joinValues(object $array, string $delimiter, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.keyAt

Source pointer: /0/method/44

```text
keyAt(object $array, int $offset): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.keyOf

Source pointer: /0/method/45

```text
keyOf(object $array, mixed $value): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.lastKey

Source pointer: /0/method/46

```text
lastKey(object $array): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.lastKeyOf

Source pointer: /0/method/47

```text
lastKeyOf(object $array, mixed $value): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.lastValue

Source pointer: /0/method/48

```text
lastValue(object $array): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.linearize

Source pointer: /0/method/49

```text
linearize(object $array, string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.listKeys

Source pointer: /0/method/50

```text
listKeys(object $array): object
```

```json
{
  "name": "listKeys",
  "description": "Lists all keys of an array.",
  "param": [
    {
      "name": "array",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[original-key, ...]"
    }
  ]
}
```

## method: Array.listValues

Source pointer: /0/method/51

```text
listValues(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.map

Source pointer: /0/method/52

```text
map(object $array, function $callback, ?object $bind): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.merge

Source pointer: /0/method/53

```text
merge(object $array, variadic $arrays): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.pad

Source pointer: /0/method/54

```text
pad(object $array, int $length, mixed $padding): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.partition

Source pointer: /0/method/55

```text
partition(object $array, int $length): object
```

```json
{
  "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, ...], ...]"
    }
  ]
}
```

## method: Array.pop

Source pointer: /0/method/56

```text
pop(object $array): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.push

Source pointer: /0/method/57

```text
push(object $array, mixed $value): object
```

```json
{
  "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]"
    }
  ]
}
```

## method: Array.randomKey

Source pointer: /0/method/58

```text
randomKey(object $array): int | string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.randomValue

Source pointer: /0/method/59

```text
randomValue(object $array): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.reduce

Source pointer: /0/method/60

```text
reduce(object $array, mixed $initial, function $callback, ?object $bind): mixed
```

```json
{
  "name": "reduce",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "initial",
      "type": "mixed"
    },
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "bind",
      "type": "?object"
    }
  ],
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: Array.reindex

Source pointer: /0/method/61

```text
reindex(object $array, int $initial): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.remove

Source pointer: /0/method/62

```text
remove(object $array, variadic $arrays): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.removeKey

Source pointer: /0/method/63

```text
removeKey(object $array, string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.removeKeys

Source pointer: /0/method/64

```text
removeKeys(object $array, object $keys): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.removeValue

Source pointer: /0/method/65

```text
removeValue(object $array, mixed $value): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.removeValues

Source pointer: /0/method/66

```text
removeValues(object $array, object $values): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.repeat

Source pointer: /0/method/67

```text
repeat(object $values, int $count): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.replace

Source pointer: /0/method/68

```text
replace(object $array, variadic $arrays): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.reverse

Source pointer: /0/method/69

```text
reverse(object $array): object
```

```json
{
  "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]"
    }
  ]
}
```

## method: Array.shift

Source pointer: /0/method/70

```text
shift(object $array): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.shuffle

Source pointer: /0/method/71

```text
shuffle(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.slice

Source pointer: /0/method/72

```text
slice(object $array, int $offset, ?int $length): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.some

Source pointer: /0/method/73

```text
some(object $array, function $callback, ?object $bind): bool
```

```json
{
  "name": "some",
  "param": [
    {
      "name": "array",
      "type": "object"
    },
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "bind",
      "type": "?object"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.sortAscByKeys

Source pointer: /0/method/74

```text
sortAscByKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortAscByValues

Source pointer: /0/method/75

```text
sortAscByValues(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortByKeys

Source pointer: /0/method/76

```text
sortByKeys(object $array, function $callback, ?object $bind): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortByValues

Source pointer: /0/method/77

```text
sortByValues(object $array, function $callback, ?object $bind, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortDescByKeys

Source pointer: /0/method/78

```text
sortDescByKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortDescByValues

Source pointer: /0/method/79

```text
sortDescByValues(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortMultidimensional

Source pointer: /0/method/80

```text
sortMultidimensional(object $array, object $callbacks, ?object $bind): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortNaturalAscByKeys

Source pointer: /0/method/81

```text
sortNaturalAscByKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortNaturalAscByValues

Source pointer: /0/method/82

```text
sortNaturalAscByValues(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortNaturalDescByKeys

Source pointer: /0/method/83

```text
sortNaturalDescByKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.sortNaturalDescByValues

Source pointer: /0/method/84

```text
sortNaturalDescByValues(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.splice

Source pointer: /0/method/85

```text
splice(object $array, int $offset, ?int $length, object $replacement): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.tail

Source pointer: /0/method/86

```text
tail(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.toCSV

Source pointer: /0/method/87

```text
toCSV(object $array, string $delimiter, bool $enclosed): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Array.toLowerKeys

Source pointer: /0/method/88

```text
toLowerKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.toLowerKeys

Source pointer: /0/method/89

```text
toLowerKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.toUpperKeys

Source pointer: /0/method/90

```text
toUpperKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.toUpperKeys

Source pointer: /0/method/91

```text
toUpperKeys(object $array): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.unionByKeys

Source pointer: /0/method/92

```text
unionByKeys(object $array, variadic $arrays): object
```

```json
{
  "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]"
    }
  ]
}
```

## method: Array.unionByValues

Source pointer: /0/method/93

```text
unionByValues(object $array, variadic $arrays): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.unique

Source pointer: /0/method/94

```text
unique(object $array, ?string $key): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.unshift

Source pointer: /0/method/95

```text
unshift(object $array, mixed $value): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Array.valueAt

Source pointer: /0/method/96

```text
valueAt(object $array, string $key): mixed | null
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: Array.Iterator

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/1
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Array.Iterator

Source pointer: /1

```json
{
  "name": "Array.Iterator",
  "static": false,
  "extend": "Base",
  "description": "Array iterator prototype."
}
```

## method: Array.Iterator.construct

Source pointer: /1/method/0

```text
construct(object $array)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "array",
      "type": "object"
    }
  ]
}
```

## method: Array.Iterator.hasMore

Source pointer: /1/method/1

```text
hasMore([parameter metadata absent]): bool
```

```json
{
  "name": "hasMore",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Array.Iterator.next

Source pointer: /1/method/2

```text
next([parameter metadata absent]): object | null
```

```json
{
  "name": "next",
  "return": [
    {
      "type": "object",
      "value": "[key: value]"
    },
    {
      "type": "null",
      "description": "if there are no more elements"
    }
  ]
}
```

## method: Array.Iterator.reset

Source pointer: /1/method/3

```text
reset([parameter metadata absent]): this
```

```json
{
  "name": "reset",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: Array.ReverseIterator

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/2
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Array.ReverseIterator

Source pointer: /2

```json
{
  "name": "Array.ReverseIterator",
  "static": false,
  "extend": "Array.Iterator",
  "description": "Array reverse iterator prototype."
}
```

# Zymba reference: Base

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/3
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Base

Source pointer: /3

```json
{
  "name": "Base",
  "static": false,
  "description": "Base prototype."
}
```

## method: Base.construct

Source pointer: /3/method/0

```text
construct([parameter metadata absent])
```

```json
{
  "name": "construct",
  "description": "Dummy fallback constructor function for ease of constructor chaining."
}
```

## method: Base.callMethod

Source pointer: /3/method/1

```text
callMethod(function $function, variadic $arguments): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: Base.clone

Source pointer: /3/method/2

```text
clone([parameter metadata absent]): object
```

```json
{
  "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"
    }
  ]
}
```

## method: Base.countSlots

Source pointer: /3/method/3

```text
countSlots([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Base.getInternalID

Source pointer: /3/method/4

```text
getInternalID([parameter metadata absent]): int
```

```json
{
  "name": "getInternalID",
  "description": "Gets the unique internal identification number of this object.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Base.isInstanceOf

Source pointer: /3/method/5

```text
isInstanceOf(mixed $prototype): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Base.listPrototypes

Source pointer: /3/method/6

```text
listPrototypes([parameter metadata absent]): object
```

```json
{
  "name": "listPrototypes",
  "description": "Lists all prototypes of this object.",
  "return": [
    {
      "type": "object",
      "value": "[prototype, ...]"
    }
  ]
}
```

## method: Base.listSlotNames

Source pointer: /3/method/7

```text
listSlotNames([parameter metadata absent]): object
```

```json
{
  "name": "listSlotNames",
  "description": "Lists all slot names of this object.",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: Base.listSlots

Source pointer: /3/method/8

```text
listSlots([parameter metadata absent]): object
```

```json
{
  "name": "listSlots",
  "description": "Lists all slots of this object.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: Base.toJSON

Source pointer: /3/method/9

```text
toJSON([parameter metadata absent]): string
```

```json
{
  "name": "toJSON",
  "description": "Returns the JavaScript Object Notation (JSON) representation of this object according to RFC 4627.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: Console

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/4
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Console

Source pointer: /4

```json
{
  "name": "Console",
  "static": true,
  "description": "Static console related functions."
}
```

## method: Console.clear

Source pointer: /4/method/0

```text
clear([parameter metadata absent])
```

```json
{
  "name": "clear",
  "description": "Clears the console by removing all messages."
}
```

## method: Console.countMessages

Source pointer: /4/method/1

```text
countMessages([parameter metadata absent]): int
```

```json
{
  "name": "countMessages",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Console.disableAssertions

Source pointer: /4/method/2

```text
disableAssertions([parameter metadata absent])
```

```json
{
  "name": "disableAssertions",
  "description": "Disables assertions.",
  "annotation": [
    "This function is complementary to \"enableAssertions\"."
  ]
}
```

## method: Console.enableAssertions

Source pointer: /4/method/3

```text
enableAssertions([parameter metadata absent])
```

```json
{
  "name": "enableAssertions",
  "description": "Enables assertions.",
  "annotation": [
    "This function is complementary to \"disableAssertions\"."
  ]
}
```

## method: Console.getSummary

Source pointer: /4/method/4

```text
getSummary([parameter metadata absent]): string
```

```json
{
  "name": "getSummary",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Console.listMessages

Source pointer: /4/method/5

```text
listMessages([parameter metadata absent]): object
```

```json
{
  "name": "listMessages",
  "return": [
    {
      "type": "object",
      "value": "[message, ...]"
    }
  ]
}
```

## method: Console.log

Source pointer: /4/method/6

```text
log(variadic $messages)
```

```json
{
  "name": "log",
  "param": [
    {
      "name": "messages",
      "type": "variadic"
    }
  ]
}
```

## constant: Console.CREATOR

Source pointer: /4/const/0

```json
{
  "name": "CREATOR",
  "type": "string",
  "description": "Zymba creator"
}
```

## constant: Console.VERSION

Source pointer: /4/const/1

```json
{
  "name": "VERSION",
  "type": "int",
  "description": "Zymba version number"
}
```

# Zymba reference: Crypt

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/5
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Crypt

Source pointer: /5

```json
{
  "name": "Crypt",
  "static": true,
  "description": "Static cryptographic functions."
}
```

## method: Crypt.convertPublicKeyRSAToPEM

Source pointer: /5/method/0

```text
convertPublicKeyRSAToPEM(string $exponent, string $modulus): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createIV

Source pointer: /5/method/1

```text
createIV(string $cipher): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createJWT

Source pointer: /5/method/2

```text
createJWT(object $claims, string $key, string $algorithm, object $header): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createNonce

Source pointer: /5/method/3

```text
createNonce(int $size): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createNonceRaw

Source pointer: /5/method/4

```text
createNonceRaw(int $size): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createPassword

Source pointer: /5/method/5

```text
createPassword(int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createTimeOrderedUUID

Source pointer: /5/method/6

```text
createTimeOrderedUUID([parameter metadata absent]): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.createUUID

Source pointer: /5/method/7

```text
createUUID([parameter metadata absent]): string
```

```json
{
  "name": "createUUID",
  "description": "Creates a version 4 universally unique identifier (UUID) from a random source according to RFC 4122.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Crypt.decrypt

Source pointer: /5/method/8

```text
decrypt(string $string, string $key, string $cipher, string $iv): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.encrypt

Source pointer: /5/method/9

```text
encrypt(string $string, string $key, string $cipher, string $iv): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.equalsTimeConstant

Source pointer: /5/method/10

```text
equalsTimeConstant(string $secret, string $input): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.hash

Source pointer: /5/method/11

```text
hash(string $string, string $algorithm, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.hashFile

Source pointer: /5/method/12

```text
hashFile(string $path, string $algorithm, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.hashFileRaw

Source pointer: /5/method/13

```text
hashFileRaw(string $path, string $algorithm, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.hashPassword

Source pointer: /5/method/14

```text
hashPassword(string $password): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.hashRaw

Source pointer: /5/method/15

```text
hashRaw(string $string, string $algorithm, ?string $key): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.listCiphers

Source pointer: /5/method/16

```text
listCiphers([parameter metadata absent]): object
```

```json
{
  "name": "listCiphers",
  "description": "Lists all available ciphers.",
  "return": [
    {
      "type": "object",
      "value": "[cipher, ...]"
    }
  ]
}
```

## method: Crypt.listHashAlgorithms

Source pointer: /5/method/17

```text
listHashAlgorithms([parameter metadata absent]): object
```

```json
{
  "name": "listHashAlgorithms",
  "description": "Lists all available hash algorithms.",
  "return": [
    {
      "type": "object",
      "value": "[algorithm, ...]"
    }
  ]
}
```

## method: Crypt.pbkdf2

Source pointer: /5/method/18

```text
pbkdf2(string $password, string $salt, string $algorithm, int $iterations, int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.pbkdf2Raw

Source pointer: /5/method/19

```text
pbkdf2Raw(string $password, string $salt, string $algorithm, int $iterations, int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.verifyJWT

Source pointer: /5/method/20

```text
verifyJWT(string $jwt, string $key): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Crypt.verifyPassword

Source pointer: /5/method/21

```text
verifyPassword(string $password, string $hash): bool
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: DNS

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/6
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: DNS

Source pointer: /6

```json
{
  "name": "DNS",
  "static": true,
  "description": "Static DNS related functions."
}
```

## method: DNS.exists

Source pointer: /6/method/0

```text
exists(string $host, string $type): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: DNS.isValidDomain

Source pointer: /6/method/1

```text
isValidDomain(string $domain): bool
```

```json
{
  "name": "isValidDomain",
  "description": "Determines whether a domain name is valid.",
  "param": [
    {
      "name": "domain",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: DNS.isValidHost

Source pointer: /6/method/2

```text
isValidHost(string $host): bool
```

```json
{
  "name": "isValidHost",
  "description": "Determines whether a host (domain name or IP address) is valid.",
  "param": [
    {
      "name": "host",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: DNS.isValidIP

Source pointer: /6/method/3

```text
isValidIP(string $ip): bool
```

```json
{
  "name": "isValidIP",
  "description": "Determines whether an IP address is valid.",
  "param": [
    {
      "name": "ip",
      "type": "string",
      "default": "\"0.0.0.0\""
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: DNS.lookup

Source pointer: /6/method/4

```text
lookup(string $domain): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: DNS.resolve

Source pointer: /6/method/5

```text
resolve(string $domain, string $type): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: DNS.reverse

Source pointer: /6/method/6

```text
reverse(string $ip): string | null
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: Date

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/7
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Date

Source pointer: /7

```json
{
  "name": "Date",
  "static": true,
  "description": "Static date and time related constants and functions."
}
```

## method: Date.create

Source pointer: /7/method/0

```text
create(?int $day, ?int $month, ?int $year, int $hour, int $minute, int $second): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.createUTC

Source pointer: /7/method/1

```text
createUTC(?int $day, ?int $month, ?int $year, int $hour, int $minute, int $second): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.format

Source pointer: /7/method/2

```text
format(string $format, ?int $timestamp): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.formatUTC

Source pointer: /7/method/3

```text
formatUTC(string $format, ?int $timestamp): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getDay

Source pointer: /7/method/4

```text
getDay(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getDayOfWeek

Source pointer: /7/method/5

```text
getDayOfWeek(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getDayOfWeekISO8601

Source pointer: /7/method/6

```text
getDayOfWeekISO8601(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getDayOfYear

Source pointer: /7/method/7

```text
getDayOfYear(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getDaysInMonth

Source pointer: /7/method/8

```text
getDaysInMonth(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getHour

Source pointer: /7/method/9

```text
getHour(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getMinute

Source pointer: /7/method/10

```text
getMinute(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getMonth

Source pointer: /7/method/11

```text
getMonth(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getSecond

Source pointer: /7/method/12

```text
getSecond(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getTimezone

Source pointer: /7/method/13

```text
getTimezone([parameter metadata absent]): string
```

```json
{
  "name": "getTimezone",
  "description": "Gets the current time zone name as defined by the IANA Time Zone Database.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Date.getTimezoneAbbreviation

Source pointer: /7/method/14

```text
getTimezoneAbbreviation([parameter metadata absent]): string
```

```json
{
  "name": "getTimezoneAbbreviation",
  "description": "Gets the current time zone abbreviation.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Date.getTimezoneOffset

Source pointer: /7/method/15

```text
getTimezoneOffset([parameter metadata absent]): int
```

```json
{
  "name": "getTimezoneOffset",
  "description": "Gets the current time zone offset in number of seconds from UTC.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Date.getWeekISO8601

Source pointer: /7/method/16

```text
getWeekISO8601(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getYear

Source pointer: /7/method/17

```text
getYear(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.getYearISO8601

Source pointer: /7/method/18

```text
getYearISO8601(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.inDST

Source pointer: /7/method/19

```text
inDST(?int $timestamp): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.isLeapYear

Source pointer: /7/method/20

```text
isLeapYear(?int $timestamp): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.isMidnight

Source pointer: /7/method/21

```text
isMidnight(?int $timestamp): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.isValid

Source pointer: /7/method/22

```text
isValid(?int $day, ?int $month, ?int $year): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.listTimezones

Source pointer: /7/method/23

```text
listTimezones([parameter metadata absent]): object
```

```json
{
  "name": "listTimezones",
  "description": "List all available time zones.",
  "return": [
    {
      "type": "object",
      "value": "[timezone, ...]"
    }
  ]
}
```

## method: Date.now

Source pointer: /7/method/24

```text
now([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.nowExact

Source pointer: /7/method/25

```text
nowExact([parameter metadata absent]): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.parse

Source pointer: /7/method/26

```text
parse(string $string): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.today

Source pointer: /7/method/27

```text
today([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.truncateDay

Source pointer: /7/method/28

```text
truncateDay(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.truncateMonth

Source pointer: /7/method/29

```text
truncateMonth(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Date.truncateYear

Source pointer: /7/method/30

```text
truncateYear(?int $timestamp): int
```

```json
{
  "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"
    }
  ]
}
```

## constant: Date.FORMAT_ISO8601

Source pointer: /7/const/0

```json
{
  "name": "FORMAT_ISO8601",
  "type": "string",
  "description": "Date and time format according to ISO 8601 (\"Y-m-d\\TH:i:sP\")"
}
```

## constant: Date.FORMAT_ISO9075

Source pointer: /7/const/1

```json
{
  "name": "FORMAT_ISO9075",
  "type": "string",
  "description": "Date and time format according to ISO 9075 (\"Y-m-d H:i:s\")"
}
```

## constant: Date.FORMAT_RFC1036

Source pointer: /7/const/2

```json
{
  "name": "FORMAT_RFC1036",
  "type": "string",
  "description": "Date and time format according to RFC 1036 (\"D, d M y H:i:s O\")"
}
```

## constant: Date.FORMAT_RFC1123

Source pointer: /7/const/3

```json
{
  "name": "FORMAT_RFC1123",
  "type": "string",
  "description": "Date and time format according to RFC 1123 (\"D, d M Y H:i:s O\")"
}
```

## constant: Date.FORMAT_RFC2822

Source pointer: /7/const/4

```json
{
  "name": "FORMAT_RFC2822",
  "type": "string",
  "description": "Date and time format according to RFC 2822 (\"D, d M Y H:i:s O\")"
}
```

## constant: Date.FORMAT_RFC3339

Source pointer: /7/const/5

```json
{
  "name": "FORMAT_RFC3339",
  "type": "string",
  "description": "Date and time format according to RFC 3339 (\"Y-m-d\\TH:i:sP\")"
}
```

## constant: Date.FORMAT_RFC822

Source pointer: /7/const/6

```json
{
  "name": "FORMAT_RFC822",
  "type": "string",
  "description": "Date and time format according to RFC 822 (\"D, d M y H:i:s O\")"
}
```

## constant: Date.FORMAT_RFC850

Source pointer: /7/const/7

```json
{
  "name": "FORMAT_RFC850",
  "type": "string",
  "description": "Date and time format according to RFC 850 (\"l, d-M-y H:i:s T\")"
}
```

## constant: Date.JUDGMENTDAY

Source pointer: /7/const/8

```json
{
  "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)"
}
```

# Zymba reference: Date.TimezoneContext

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/8
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Date.TimezoneContext

Source pointer: /8

```json
{
  "name": "Date.TimezoneContext",
  "static": false,
  "extend": "Base",
  "description": "Timezone context prototype."
}
```

## method: Date.TimezoneContext.construct

Source pointer: /8/method/0

```text
construct(string $timezone)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "timezone",
      "type": "string",
      "default": "\"UTC\""
    }
  ]
}
```

## method: Date.TimezoneContext.enter

Source pointer: /8/method/1

```text
enter([parameter metadata absent])
```

```json
{
  "name": "enter"
}
```

## method: Date.TimezoneContext.exit

Source pointer: /8/method/2

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit"
}
```

# Zymba reference: Exception

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/9
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Exception

Source pointer: /9

```json
{
  "name": "Exception",
  "static": false,
  "extend": "Base",
  "description": "Exception prototype."
}
```

## method: Exception.construct

Source pointer: /9/method/0

```text
construct(string $message)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "message",
      "type": "string"
    }
  ]
}
```

## method: Exception.countTraces

Source pointer: /9/method/1

```text
countTraces([parameter metadata absent]): int
```

```json
{
  "name": "countTraces",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Exception.getInitialTrace

Source pointer: /9/method/2

```text
getInitialTrace([parameter metadata absent]): object | null
```

```json
{
  "name": "getInitialTrace",
  "return": [
    {
      "type": "object",
      "value": "[\"filename\": ..., \"line\": ..., \"site\": ..., \"function\": ..., \"params\": ...]"
    },
    {
      "type": "null",
      "description": "if there is no initial trace"
    }
  ]
}
```

## method: Exception.getInternalState

Source pointer: /9/method/3

```text
getInternalState([parameter metadata absent]): object | null
```

```json
{
  "name": "getInternalState",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    },
    {
      "type": "null",
      "description": "if there is no internal state"
    }
  ]
}
```

## method: Exception.getMessage

Source pointer: /9/method/4

```text
getMessage([parameter metadata absent]): string
```

```json
{
  "name": "getMessage",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Exception.getSummary

Source pointer: /9/method/5

```text
getSummary([parameter metadata absent]): string
```

```json
{
  "name": "getSummary",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Exception.getTracesAsString

Source pointer: /9/method/6

```text
getTracesAsString([parameter metadata absent]): string
```

```json
{
  "name": "getTracesAsString",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Exception.listTraces

Source pointer: /9/method/7

```text
listTraces([parameter metadata absent]): object
```

```json
{
  "name": "listTraces",
  "return": [
    {
      "type": "object",
      "value": "[[\"filename\": ..., \"line\": ..., \"site\": ..., \"function\": ..., \"params\": ...], ...]"
    }
  ]
}
```

## method: Exception.toString

Source pointer: /9/method/8

```text
toString([parameter metadata absent]): string
```

```json
{
  "name": "toString",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: FTP

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/10
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: FTP

Source pointer: /10

```json
{
  "name": "FTP",
  "static": true,
  "description": "Static FTP related prototypes."
}
```

# Zymba reference: FTP.Client

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/11
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: FTP.Client

Source pointer: /11

```json
{
  "name": "FTP.Client",
  "static": false,
  "extend": "Base",
  "description": "FTP client prototype."
}
```

## method: FTP.Client.construct

Source pointer: /11/method/0

```text
construct(string $server, string $username, string $password, int $timeout)
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.append

Source pointer: /11/method/1

```text
append(string $path, string $target): this
```

```json
{
  "name": "append",
  "description": "Appends an existing file to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.close

Source pointer: /11/method/2

```text
close([parameter metadata absent])
```

```json
{
  "name": "close",
  "description": "Closes this client and frees its associated resources."
}
```

## method: FTP.Client.countDirectories

Source pointer: /11/method/3

```text
countDirectories(string $path): int
```

```json
{
  "name": "countDirectories",
  "description": "Counts the total number of subdirectories in an existing directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: FTP.Client.countFiles

Source pointer: /11/method/4

```text
countFiles(string $path): int
```

```json
{
  "name": "countFiles",
  "description": "Counts the total number of files in an existing directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: FTP.Client.createDirectory

Source pointer: /11/method/5

```text
createDirectory(string $path): this
```

```json
{
  "name": "createDirectory",
  "description": "Creates a directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.delete

Source pointer: /11/method/6

```text
delete(string $path): this
```

```json
{
  "name": "delete",
  "description": "Deletes an existing file.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.disablePassiveMode

Source pointer: /11/method/7

```text
disablePassiveMode([parameter metadata absent]): this
```

```json
{
  "name": "disablePassiveMode",
  "description": "Disables passive mode for this client.",
  "annotation": [
    "This function is complementary to \"enablePassiveMode\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.download

Source pointer: /11/method/8

```text
download(string $path, string $target): this
```

```json
{
  "name": "download",
  "description": "Downloads an existing file to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.echo

Source pointer: /11/method/9

```text
echo(string $path): this
```

```json
{
  "name": "echo",
  "description": "Outputs the content of an existing file.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.enablePassiveMode

Source pointer: /11/method/10

```text
enablePassiveMode([parameter metadata absent]): this
```

```json
{
  "name": "enablePassiveMode",
  "description": "Enables passive mode for this client.",
  "annotation": [
    "This function is complementary to \"disablePassiveMode\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.execute

Source pointer: /11/method/11

```text
execute(string $command): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.exists

Source pointer: /11/method/12

```text
exists(string $path): bool
```

```json
{
  "name": "exists",
  "description": "Determines whether a path exists.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: FTP.Client.exit

Source pointer: /11/method/13

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit",
  "description": "Closes this client and frees its associated resources for the purpose of contextualization."
}
```

## method: FTP.Client.getLastModified

Source pointer: /11/method/14

```text
getLastModified(string $path): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.getSize

Source pointer: /11/method/15

```text
getSize(string $path): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.getWorkingDirectory

Source pointer: /11/method/16

```text
getWorkingDirectory([parameter metadata absent]): string
```

```json
{
  "name": "getWorkingDirectory",
  "description": "Gets the path of the current working directory.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: FTP.Client.isConnected

Source pointer: /11/method/17

```text
isConnected([parameter metadata absent]): bool
```

```json
{
  "name": "isConnected",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: FTP.Client.isDirectory

Source pointer: /11/method/18

```text
isDirectory(string $path): bool
```

```json
{
  "name": "isDirectory",
  "description": "Determines whether a path exists and refers to a directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: FTP.Client.listDirectories

Source pointer: /11/method/19

```text
listDirectories(string $path): object
```

```json
{
  "name": "listDirectories",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[filename, ...]"
    }
  ]
}
```

## method: FTP.Client.listFiles

Source pointer: /11/method/20

```text
listFiles(string $path): object
```

```json
{
  "name": "listFiles",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[filename, ...]"
    }
  ]
}
```

## method: FTP.Client.move

Source pointer: /11/method/21

```text
move(string $path, string $target): this
```

```json
{
  "name": "move",
  "description": "Moves an existing file to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.read

Source pointer: /11/method/22

```text
read(string $path, ?int $length, int $position): string
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.readCSV

Source pointer: /11/method/23

```text
readCSV(string $path, string $delimiter): object
```

```json
{
  "name": "readCSV",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "delimiter",
      "type": "string",
      "default": "\";\""
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[[value, ...], ...]"
    }
  ]
}
```

## method: FTP.Client.readJSON

Source pointer: /11/method/24

```text
readJSON(string $path): mixed
```

```json
{
  "name": "readJSON",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: FTP.Client.setPermissions

Source pointer: /11/method/25

```text
setPermissions(string $path, int $mode): this
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.setTimeout

Source pointer: /11/method/26

```text
setTimeout(int $timeout): this
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.setWorkingDirectory

Source pointer: /11/method/27

```text
setWorkingDirectory(string $path): this
```

```json
{
  "name": "setWorkingDirectory",
  "description": "Sets the path of the working directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: FTP.Client.upload

Source pointer: /11/method/28

```text
upload(string $path, string $target, int $position): this
```

```json
{
  "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"
    }
  ]
}
```

## method: FTP.Client.write

Source pointer: /11/method/29

```text
write(string $path, string $string, ?int $length, int $position): int
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: Function

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/12
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Function

Source pointer: /12

```json
{
  "name": "Function",
  "static": true,
  "description": "Static function related functions."
}
```

## method: Function.call

Source pointer: /12/method/0

```text
call(function $function, ?object $bind, variadic $arguments): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: Function.countParameters

Source pointer: /12/method/1

```text
countParameters(function $function): int
```

```json
{
  "name": "countParameters",
  "description": "Counts the total number of parameters of a function.",
  "param": [
    {
      "name": "function",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Function.isInternal

Source pointer: /12/method/2

```text
isInternal(function $function): bool
```

```json
{
  "name": "isInternal",
  "description": "Determines whether a function is internal.",
  "param": [
    {
      "name": "function",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Function.isUserDefined

Source pointer: /12/method/3

```text
isUserDefined(function $function): bool
```

```json
{
  "name": "isUserDefined",
  "description": "Determines whether a function is user-defined.",
  "param": [
    {
      "name": "function",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Function.isVariadic

Source pointer: /12/method/4

```text
isVariadic(function $function): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Function.listParameterNames

Source pointer: /12/method/5

```text
listParameterNames(function $function): object
```

```json
{
  "name": "listParameterNames",
  "description": "Lists all parameter names of a function.",
  "param": [
    {
      "name": "function",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: Function.listParameters

Source pointer: /12/method/6

```text
listParameters(function $function): object
```

```json
{
  "name": "listParameters",
  "description": "Lists all parameters of a function with associated default values.",
  "param": [
    {
      "name": "function",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[name: default, ...]"
    }
  ]
}
```

# Zymba reference: Generator

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/13
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Generator

Source pointer: /13

```json
{
  "name": "Generator",
  "static": false,
  "extend": "Base",
  "description": "Abstract generator prototype."
}
```

## method: Generator.getResult

Source pointer: /13/method/0

```text
getResult([parameter metadata absent]): mixed | null
```

```json
{
  "name": "getResult",
  "return": [
    {
      "type": "mixed"
    },
    {
      "type": "null",
      "description": "if there is no result yet"
    }
  ]
}
```

## method: Generator.next

Source pointer: /13/method/1

```text
next([parameter metadata absent]): object | null
```

```json
{
  "name": "next",
  "description": "Resumes this generator.",
  "return": [
    {
      "type": "object",
      "value": "[key: value]"
    },
    {
      "type": "null",
      "description": "if there is no more to yield"
    }
  ]
}
```

## method: Generator.send

Source pointer: /13/method/2

```text
send(mixed $value): object | null
```

```json
{
  "name": "send",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[key: value]"
    },
    {
      "type": "null",
      "description": "if there is no more to yield"
    }
  ]
}
```

## method: Generator.throw

Source pointer: /13/method/3

```text
throw(mixed $exception): object | null
```

```json
{
  "name": "throw",
  "param": [
    {
      "name": "exception",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[key: value]"
    },
    {
      "type": "null",
      "description": "if there is no more to yield"
    }
  ]
}
```

# Zymba reference: HTTP

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/14
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: HTTP

Source pointer: /14

```json
{
  "name": "HTTP",
  "static": true,
  "description": "Static HTTP related functions."
}
```

## method: HTTP.canSendHeaders

Source pointer: /14/method/0

```text
canSendHeaders([parameter metadata absent]): bool
```

```json
{
  "name": "canSendHeaders",
  "description": "Determines whether HTTP response headers can be sent.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: HTTP.clearHeaders

Source pointer: /14/method/1

```text
clearHeaders([parameter metadata absent])
```

```json
{
  "name": "clearHeaders",
  "description": "Removes all previously set HTTP response headers."
}
```

## method: HTTP.countRequestHeaders

Source pointer: /14/method/2

```text
countRequestHeaders([parameter metadata absent]): int
```

```json
{
  "name": "countRequestHeaders",
  "description": "Counts the total number of HTTP request headers.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: HTTP.countResponseHeaders

Source pointer: /14/method/3

```text
countResponseHeaders([parameter metadata absent]): int
```

```json
{
  "name": "countResponseHeaders",
  "description": "Counts the total number of HTTP response headers.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: HTTP.getAuthenticationPassword

Source pointer: /14/method/4

```text
getAuthenticationPassword([parameter metadata absent]): string
```

```json
{
  "name": "getAuthenticationPassword",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getAuthenticationUser

Source pointer: /14/method/5

```text
getAuthenticationUser([parameter metadata absent]): string
```

```json
{
  "name": "getAuthenticationUser",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getDocumentRoot

Source pointer: /14/method/6

```text
getDocumentRoot([parameter metadata absent]): string
```

```json
{
  "name": "getDocumentRoot",
  "description": "Gets the path of the local server's document root directory.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getLocalAddress

Source pointer: /14/method/7

```text
getLocalAddress([parameter metadata absent]): string
```

```json
{
  "name": "getLocalAddress",
  "description": "Gets the IP address of the local server.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getLocalHost

Source pointer: /14/method/8

```text
getLocalHost([parameter metadata absent]): string
```

```json
{
  "name": "getLocalHost",
  "description": "Gets the host name of the local server.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getLocalPort

Source pointer: /14/method/9

```text
getLocalPort([parameter metadata absent]): int
```

```json
{
  "name": "getLocalPort",
  "description": "Gets the port number of the local server.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: HTTP.getRemoteAddress

Source pointer: /14/method/10

```text
getRemoteAddress([parameter metadata absent]): string
```

```json
{
  "name": "getRemoteAddress",
  "description": "Gets the IP address of the remote client.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRemoteHost

Source pointer: /14/method/11

```text
getRemoteHost([parameter metadata absent]): string
```

```json
{
  "name": "getRemoteHost",
  "description": "Gets the host name of the remote client.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRemotePort

Source pointer: /14/method/12

```text
getRemotePort([parameter metadata absent]): int
```

```json
{
  "name": "getRemotePort",
  "description": "Gets the port number of the remote client.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: HTTP.getRequestBody

Source pointer: /14/method/13

```text
getRequestBody([parameter metadata absent]): string
```

```json
{
  "name": "getRequestBody",
  "description": "Gets the HTTP request body in raw format.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRequestCookie

Source pointer: /14/method/14

```text
getRequestCookie(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getRequestFileUpload

Source pointer: /14/method/15

```text
getRequestFileUpload(string $name): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getRequestFormVariable

Source pointer: /14/method/16

```text
getRequestFormVariable(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getRequestHeader

Source pointer: /14/method/17

```text
getRequestHeader(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getRequestMethod

Source pointer: /14/method/18

```text
getRequestMethod([parameter metadata absent]): string
```

```json
{
  "name": "getRequestMethod",
  "description": "Gets the HTTP request method.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRequestQuery

Source pointer: /14/method/19

```text
getRequestQuery([parameter metadata absent]): string
```

```json
{
  "name": "getRequestQuery",
  "description": "Gets the query component of the HTTP request URL.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRequestQueryVariable

Source pointer: /14/method/20

```text
getRequestQueryVariable(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getRequestType

Source pointer: /14/method/21

```text
getRequestType([parameter metadata absent]): string
```

```json
{
  "name": "getRequestType",
  "description": "Gets the content type of the HTTP request.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRequestURL

Source pointer: /14/method/22

```text
getRequestURL([parameter metadata absent]): string
```

```json
{
  "name": "getRequestURL",
  "description": "Gets the complete HTTP request URL.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: HTTP.getRequestVariable

Source pointer: /14/method/23

```text
getRequestVariable(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getResponseHeader

Source pointer: /14/method/24

```text
getResponseHeader(string $name): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.getStatusCode

Source pointer: /14/method/25

```text
getStatusCode([parameter metadata absent]): int
```

```json
{
  "name": "getStatusCode",
  "description": "Gets the current HTTP response status code.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: HTTP.isConnectionAborted

Source pointer: /14/method/26

```text
isConnectionAborted([parameter metadata absent]): bool
```

```json
{
  "name": "isConnectionAborted",
  "description": "Determines whether the current connection is aborted, meaning the client has disconnected.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: HTTP.isConnectionSecure

Source pointer: /14/method/27

```text
isConnectionSecure([parameter metadata absent]): bool
```

```json
{
  "name": "isConnectionSecure",
  "description": "Determines whether the current connection is secure, meaning over HTTPS.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: HTTP.listRequestCookies

Source pointer: /14/method/28

```text
listRequestCookies([parameter metadata absent]): object
```

```json
{
  "name": "listRequestCookies",
  "description": "Lists all HTTP request cookies.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: HTTP.listRequestFileUploads

Source pointer: /14/method/29

```text
listRequestFileUploads([parameter metadata absent]): object
```

```json
{
  "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\": ...], ...]"
    }
  ]
}
```

## method: HTTP.listRequestFormVariables

Source pointer: /14/method/30

```text
listRequestFormVariables([parameter metadata absent]): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: HTTP.listRequestHeaderNames

Source pointer: /14/method/31

```text
listRequestHeaderNames([parameter metadata absent]): object
```

```json
{
  "name": "listRequestHeaderNames",
  "description": "Lists all HTTP request header names.",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: HTTP.listRequestHeaders

Source pointer: /14/method/32

```text
listRequestHeaders([parameter metadata absent]): object
```

```json
{
  "name": "listRequestHeaders",
  "description": "Lists all HTTP request headers.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: HTTP.listRequestQueryVariables

Source pointer: /14/method/33

```text
listRequestQueryVariables([parameter metadata absent]): object
```

```json
{
  "name": "listRequestQueryVariables",
  "description": "Lists all HTTP request variables submitted via the URL query component.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: HTTP.listRequestVariables

Source pointer: /14/method/34

```text
listRequestVariables([parameter metadata absent]): object
```

```json
{
  "name": "listRequestVariables",
  "description": "Lists all HTTP request variables.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: HTTP.listResponseHeaderNames

Source pointer: /14/method/35

```text
listResponseHeaderNames([parameter metadata absent]): object
```

```json
{
  "name": "listResponseHeaderNames",
  "description": "Lists all HTTP response header names.",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: HTTP.listResponseHeaders

Source pointer: /14/method/36

```text
listResponseHeaders([parameter metadata absent]): object
```

```json
{
  "name": "listResponseHeaders",
  "description": "Lists all HTTP response headers.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: HTTP.removeHeader

Source pointer: /14/method/37

```text
removeHeader(string $name)
```

```json
{
  "name": "removeHeader",
  "description": "Removes a HTTP response header.",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: HTTP.removeHeaders

Source pointer: /14/method/38

```text
removeHeaders(object $names)
```

```json
{
  "name": "removeHeaders",
  "description": "Removes multiple HTTP response headers.",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: HTTP.request

Source pointer: /14/method/39

```text
request(string $url, string $method, string $body, object $headers, int $timeout, bool $validate): object
```

```json
{
  "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\": ...]"
    }
  ]
}
```

## method: HTTP.requestBody

Source pointer: /14/method/40

```text
requestBody(string $url, string $method, string $body, object $headers, int $timeout, bool $validate): string
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.setBasicAuthentication

Source pointer: /14/method/41

```text
setBasicAuthentication(string $realm)
```

```json
{
  "name": "setBasicAuthentication",
  "param": [
    {
      "name": "realm",
      "type": "string"
    }
  ]
}
```

## method: HTTP.setCacheExpires

Source pointer: /14/method/42

```text
setCacheExpires(int $seconds)
```

```json
{
  "name": "setCacheExpires",
  "param": [
    {
      "name": "seconds",
      "type": "int",
      "default": "86400"
    }
  ]
}
```

## method: HTTP.setCookie

Source pointer: /14/method/43

```text
setCookie(string $name, string $value, int $expires, string $path, string $domain, bool $secure, bool $httponly)
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.setHeader

Source pointer: /14/method/44

```text
setHeader(string $name, string $value)
```

```json
{
  "name": "setHeader",
  "description": "Sets a HTTP response header.",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "string"
    }
  ]
}
```

## method: HTTP.setHeaders

Source pointer: /14/method/45

```text
setHeaders(object $headers, string $prefix)
```

```json
{
  "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"
    }
  ]
}
```

## method: HTTP.setStatusCode

Source pointer: /14/method/46

```text
setStatusCode(int $code)
```

```json
{
  "name": "setStatusCode",
  "description": "Sets the HTTP response status code.",
  "param": [
    {
      "name": "code",
      "type": "int",
      "default": "200"
    }
  ]
}
```

# Zymba reference: IO

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/15
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO

Source pointer: /15

```json
{
  "name": "IO",
  "static": true,
  "description": "Static IO related constants, prototypes and functions."
}
```

## method: IO.append

Source pointer: /15/method/0

```text
append(string $path, string $string): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.appendLine

Source pointer: /15/method/1

```text
appendLine(string $path, string $string): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.canExecute

Source pointer: /15/method/2

```text
canExecute(string $path): bool
```

```json
{
  "name": "canExecute",
  "description": "Determines whether a file exists and can be executed.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.canRead

Source pointer: /15/method/3

```text
canRead(string $path): bool
```

```json
{
  "name": "canRead",
  "description": "Determines whether a file exists and can be read from.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.canWrite

Source pointer: /15/method/4

```text
canWrite(string $path): bool
```

```json
{
  "name": "canWrite",
  "description": "Determines whether a file exists and can be written to.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.copy

Source pointer: /15/method/5

```text
copy(string $path, string $target)
```

```json
{
  "name": "copy",
  "description": "Copies an existing file to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ]
}
```

## method: IO.countDirectories

Source pointer: /15/method/6

```text
countDirectories(string $path): int
```

```json
{
  "name": "countDirectories",
  "description": "Counts the total number of subdirectories in an existing directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.countFiles

Source pointer: /15/method/7

```text
countFiles(string $path): int
```

```json
{
  "name": "countFiles",
  "description": "Counts the total number of files in an existing directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.crc32

Source pointer: /15/method/8

```text
crc32(string $path): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.createDirectories

Source pointer: /15/method/9

```text
createDirectories(string $path, int $mode)
```

```json
{
  "name": "createDirectories",
  "description": "Creates directories recursively.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "mode",
      "type": "int",
      "default": "0o777"
    }
  ]
}
```

## method: IO.createDirectory

Source pointer: /15/method/10

```text
createDirectory(string $path, int $mode)
```

```json
{
  "name": "createDirectory",
  "description": "Creates a directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "mode",
      "type": "int",
      "default": "0o777"
    }
  ]
}
```

## method: IO.createFile

Source pointer: /15/method/11

```text
createFile(string $path): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.createHardLink

Source pointer: /15/method/12

```text
createHardLink(string $path, string $target)
```

```json
{
  "name": "createHardLink",
  "description": "Creates a hard link to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ]
}
```

## method: IO.createSymbolicLink

Source pointer: /15/method/13

```text
createSymbolicLink(string $path, string $target)
```

```json
{
  "name": "createSymbolicLink",
  "description": "Creates a symbolic link to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ]
}
```

## method: IO.createTempFile

Source pointer: /15/method/14

```text
createTempFile(string $prefix): string
```

```json
{
  "name": "createTempFile",
  "description": "Creates an empty temporary file and returns its absolute path.",
  "param": [
    {
      "name": "prefix",
      "type": "string",
      "default": "\"z\""
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.delete

Source pointer: /15/method/15

```text
delete(string $path): string
```

```json
{
  "name": "delete",
  "description": "Deletes an existing file.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.deleteIfExists

Source pointer: /15/method/16

```text
deleteIfExists(string $path): bool
```

```json
{
  "name": "deleteIfExists",
  "description": "Deletes a file if it exists and return whether it existed.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.echo

Source pointer: /15/method/17

```text
echo(string $path): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.execute

Source pointer: /15/method/18

```text
execute(string $command): string
```

```json
{
  "name": "execute",
  "description": "Executes a shell command and returns its output.",
  "param": [
    {
      "name": "command",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.executeFlushed

Source pointer: /15/method/19

```text
executeFlushed(string $command): int
```

```json
{
  "name": "executeFlushed",
  "description": "Executes a shell command, immediately flushes its output and returns the exit code.",
  "param": [
    {
      "name": "command",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.exists

Source pointer: /15/method/20

```text
exists(string $path): bool
```

```json
{
  "name": "exists",
  "description": "Determines whether a path exists.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.getFreeSpace

Source pointer: /15/method/21

```text
getFreeSpace(string $path): float
```

```json
{
  "name": "getFreeSpace",
  "description": "Gets the free space of a filesystem in number of bytes.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: IO.getGroupID

Source pointer: /15/method/22

```text
getGroupID(string $path): int
```

```json
{
  "name": "getGroupID",
  "description": "Gets the group ID of an existing file.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.getLastAccess

Source pointer: /15/method/23

```text
getLastAccess([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.getLastModified

Source pointer: /15/method/24

```text
getLastModified([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.getPermissions

Source pointer: /15/method/25

```text
getPermissions([parameter metadata absent]): int
```

```json
{
  "name": "getPermissions",
  "description": "Gets the permissions of an existing file as the numeric mode.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.getSize

Source pointer: /15/method/26

```text
getSize(string $path): int
```

```json
{
  "name": "getSize",
  "description": "Gets the size of an existing file in number of bytes.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.getTotalSpace

Source pointer: /15/method/27

```text
getTotalSpace(string $path): float
```

```json
{
  "name": "getTotalSpace",
  "description": "Gets the total space of a filesystem in number of bytes.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: IO.getUsedSpace

Source pointer: /15/method/28

```text
getUsedSpace(string $path): float
```

```json
{
  "name": "getUsedSpace",
  "description": "Gets the used space of a filesystem in number of bytes.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: IO.getUserID

Source pointer: /15/method/29

```text
getUserID(string $path): int
```

```json
{
  "name": "getUserID",
  "description": "Gets the user ID of an existing file.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.hasExistingTarget

Source pointer: /15/method/30

```text
hasExistingTarget(string $path): bool
```

```json
{
  "name": "hasExistingTarget",
  "description": "Determines whether a symbolic link has an existing target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.hasSameContent

Source pointer: /15/method/31

```text
hasSameContent(string $path1, string $path2): bool
```

```json
{
  "name": "hasSameContent",
  "description": "Determines whether two existing files have the same content.",
  "param": [
    {
      "name": "path1",
      "type": "string"
    },
    {
      "name": "path2",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.isDirectory

Source pointer: /15/method/32

```text
isDirectory(string $path): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.isFile

Source pointer: /15/method/33

```text
isFile(string $path): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.isRegularDirectory

Source pointer: /15/method/34

```text
isRegularDirectory(string $path): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.isRegularFile

Source pointer: /15/method/35

```text
isRegularFile(string $path): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.isSameFile

Source pointer: /15/method/36

```text
isSameFile(string $path1, string $path2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.isSymbolicLink

Source pointer: /15/method/37

```text
isSymbolicLink(string $path): bool
```

```json
{
  "name": "isSymbolicLink",
  "description": "Determines whether a path exists and refers to a symbolic link.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.listDirectories

Source pointer: /15/method/38

```text
listDirectories(string $path): object
```

```json
{
  "name": "listDirectories",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[filename, ...]"
    }
  ]
}
```

## method: IO.listFiles

Source pointer: /15/method/39

```text
listFiles(string $path): object
```

```json
{
  "name": "listFiles",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[filename, ...]"
    }
  ]
}
```

## method: IO.move

Source pointer: /15/method/40

```text
move(string $path, string $target)
```

```json
{
  "name": "move",
  "description": "Moves an existing file to a specific target.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ]
}
```

## method: IO.quoteCommandArgument

Source pointer: /15/method/41

```text
quoteCommandArgument(string $argument): string
```

```json
{
  "name": "quoteCommandArgument",
  "param": [
    {
      "name": "argument",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.read

Source pointer: /15/method/42

```text
read(string $path, ?int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.readCSV

Source pointer: /15/method/43

```text
readCSV(string $path, string $delimiter): object
```

```json
{
  "name": "readCSV",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "delimiter",
      "type": "string",
      "default": "\";\""
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[[value, ...], ...]"
    }
  ]
}
```

## method: IO.readJSON

Source pointer: /15/method/44

```text
readJSON(string $path): mixed
```

```json
{
  "name": "readJSON",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: IO.readLines

Source pointer: /15/method/45

```text
readLines(string $path): object
```

```json
{
  "name": "readLines",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[line, ...]"
    }
  ]
}
```

## method: IO.readModifyWrite

Source pointer: /15/method/46

```text
readModifyWrite(string $path, function $callback, ?object $bind): string
```

```json
{
  "name": "readModifyWrite",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "bind",
      "type": "?object"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.readNonEmptyLines

Source pointer: /15/method/47

```text
readNonEmptyLines(string $path): object
```

```json
{
  "name": "readNonEmptyLines",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[line, ...]"
    }
  ]
}
```

## method: IO.readSymbolicLink

Source pointer: /15/method/48

```text
readSymbolicLink(string $path): string
```

```json
{
  "name": "readSymbolicLink",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.selectReadyStreams

Source pointer: /15/method/49

```text
selectReadyStreams(?object $read, ?object $write, ?object $exceptional, ?number $timeout): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.setGroupByID

Source pointer: /15/method/50

```text
setGroupByID(string $path, int $id)
```

```json
{
  "name": "setGroupByID",
  "description": "Sets the group of an exiting file by ID.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "id",
      "type": "int"
    }
  ]
}
```

## method: IO.setGroupByName

Source pointer: /15/method/51

```text
setGroupByName(string $path, string $name)
```

```json
{
  "name": "setGroupByName",
  "description": "Sets the group of an exiting file by name.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: IO.setLastAccess

Source pointer: /15/method/52

```text
setLastAccess(string $path, ?int $timestamp)
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.setLastModified

Source pointer: /15/method/53

```text
setLastModified(string $path, ?int $timestamp)
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.setPermissions

Source pointer: /15/method/54

```text
setPermissions(string $path, int $mode)
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.setUserByID

Source pointer: /15/method/55

```text
setUserByID(string $path, int $id)
```

```json
{
  "name": "setUserByID",
  "description": "Sets the user of an exiting file by ID.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "id",
      "type": "int"
    }
  ]
}
```

## method: IO.setUserByName

Source pointer: /15/method/56

```text
setUserByName(string $path, string $name)
```

```json
{
  "name": "setUserByName",
  "description": "Sets the user of an exiting file by name.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: IO.truncate

Source pointer: /15/method/57

```text
truncate(string $path, int $size)
```

```json
{
  "name": "truncate",
  "description": "Truncates an existing file to a specific size in number of bytes.",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "size",
      "type": "int"
    }
  ]
}
```

## method: IO.write

Source pointer: /15/method/58

```text
write(string $path, string $string, ?int $length): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.writeCSV

Source pointer: /15/method/59

```text
writeCSV(string $path, object $array, string $delimiter): int
```

```json
{
  "name": "writeCSV",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "array",
      "type": "object",
      "value": "[[value, ...], ...]"
    },
    {
      "name": "delimiter",
      "type": "string",
      "default": "\";\""
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.writeJSON

Source pointer: /15/method/60

```text
writeJSON(string $path, mixed $value): int
```

```json
{
  "name": "writeJSON",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## constant: IO.EOL

Source pointer: /15/const/0

```json
{
  "name": "EOL",
  "type": "string",
  "description": "End-of-line sequence"
}
```

# Zymba reference: IO.DirectoryIterator

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/16
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.DirectoryIterator

Source pointer: /16

```json
{
  "name": "IO.DirectoryIterator",
  "static": false,
  "extend": "Base",
  "description": "IO directory iterator prototype."
}
```

## method: IO.DirectoryIterator.construct

Source pointer: /16/method/0

```text
construct(string $path)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ]
}
```

## method: IO.DirectoryIterator.hasMore

Source pointer: /16/method/1

```text
hasMore([parameter metadata absent]): bool
```

```json
{
  "name": "hasMore",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.DirectoryIterator.next

Source pointer: /16/method/2

```text
next([parameter metadata absent]): object | null
```

```json
{
  "name": "next",
  "return": [
    {
      "type": "object",
      "value": "[path: filename]"
    },
    {
      "type": "null",
      "description": "if there are no more files"
    }
  ]
}
```

## method: IO.DirectoryIterator.reset

Source pointer: /16/method/3

```text
reset([parameter metadata absent]): this
```

```json
{
  "name": "reset",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: IO.FileStream

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/17
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.FileStream

Source pointer: /17

```json
{
  "name": "IO.FileStream",
  "static": false,
  "extend": "IO.Stream",
  "description": "IO file stream prototype."
}
```

## method: IO.FileStream.construct

Source pointer: /17/method/0

```text
construct(string $path, int $mode)
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.FileStream.attemptLock

Source pointer: /17/method/1

```text
attemptLock([parameter metadata absent]): bool
```

```json
{
  "name": "attemptLock",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.FileStream.attemptLockShared

Source pointer: /17/method/2

```text
attemptLockShared([parameter metadata absent]): bool
```

```json
{
  "name": "attemptLockShared",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.FileStream.canLock

Source pointer: /17/method/3

```text
canLock([parameter metadata absent]): bool
```

```json
{
  "name": "canLock",
  "description": "Determines whether this stream can be locked.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.FileStream.getSize

Source pointer: /17/method/4

```text
getSize([parameter metadata absent]): int
```

```json
{
  "name": "getSize",
  "description": "Gets the size of this stream in number of bytes.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.FileStream.lock

Source pointer: /17/method/5

```text
lock([parameter metadata absent]): this
```

```json
{
  "name": "lock",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.FileStream.lockShared

Source pointer: /17/method/6

```text
lockShared([parameter metadata absent]): this
```

```json
{
  "name": "lockShared",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.FileStream.pad

Source pointer: /17/method/7

```text
pad(int $size, string $padding): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.FileStream.selectLock

Source pointer: /17/method/8

```text
selectLock([parameter metadata absent]): @IO.LockContext
```

```json
{
  "name": "selectLock",
  "return": [
    {
      "type": "@IO.LockContext"
    }
  ]
}
```

## method: IO.FileStream.sync

Source pointer: /17/method/9

```text
sync([parameter metadata absent]): bool
```

```json
{
  "name": "sync",
  "description": "Synchonizes this stream with the underlying storage device, including modified metadata.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.FileStream.syncData

Source pointer: /17/method/10

```text
syncData([parameter metadata absent]): bool
```

```json
{
  "name": "syncData",
  "description": "Synchonizes this stream with the underlying storage device, excluding modified metadata (if possible).",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.FileStream.unlock

Source pointer: /17/method/11

```text
unlock([parameter metadata absent]): this
```

```json
{
  "name": "unlock",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## constant: IO.FileStream.MODE_CREATE

Source pointer: /17/const/0

```json
{
  "name": "MODE_CREATE",
  "type": "int",
  "description": "File stream create mode, implies write mode"
}
```

## constant: IO.FileStream.MODE_TRUNCATE

Source pointer: /17/const/1

```json
{
  "name": "MODE_TRUNCATE",
  "type": "int",
  "description": "File stream truncate mode, implies write mode"
}
```

## constant: IO.FileStream.MODE_APPEND

Source pointer: /17/const/2

```json
{
  "name": "MODE_APPEND",
  "type": "int",
  "description": "File stream append mode, implies create mode"
}
```

## constant: IO.FileStream.MODE_OVERWRITE

Source pointer: /17/const/3

```json
{
  "name": "MODE_OVERWRITE",
  "type": "int",
  "description": "File stream overwrite mode, same as create plus truncate mode"
}
```

# Zymba reference: IO.LockContext

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/18
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.LockContext

Source pointer: /18

```json
{
  "name": "IO.LockContext",
  "static": false,
  "extend": "Base",
  "description": "Abstract IO lock context prototype."
}
```

## method: IO.LockContext.enter

Source pointer: /18/method/0

```text
enter([parameter metadata absent])
```

```json
{
  "name": "enter"
}
```

## method: IO.LockContext.exit

Source pointer: /18/method/1

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit"
}
```

# Zymba reference: IO.Process

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/19
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.Process

Source pointer: /19

```json
{
  "name": "IO.Process",
  "static": false,
  "extend": "Base",
  "description": "IO process prototype."
}
```

## method: IO.Process.construct

Source pointer: /19/method/0

```text
construct(string $command, string $path, ?object $environment)
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Process.close

Source pointer: /19/method/1

```text
close([parameter metadata absent]): int
```

```json
{
  "name": "close",
  "description": "Closes this process, frees its associated resources and returns its exit code.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Process.exit

Source pointer: /19/method/2

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit",
  "description": "Closes this process and frees its associated resources for the purpose of contextualization."
}
```

## method: IO.Process.getCommand

Source pointer: /19/method/3

```text
getCommand([parameter metadata absent]): string
```

```json
{
  "name": "getCommand",
  "description": "Gets the command that created this process.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.Process.getExitCode

Source pointer: /19/method/4

```text
getExitCode([parameter metadata absent]): int
```

```json
{
  "name": "getExitCode",
  "description": "Gets the exit code returned by this process.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Process.getProcessID

Source pointer: /19/method/5

```text
getProcessID([parameter metadata absent]): int
```

```json
{
  "name": "getProcessID",
  "description": "Gets the process ID.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Process.isRunning

Source pointer: /19/method/6

```text
isRunning([parameter metadata absent]): bool
```

```json
{
  "name": "isRunning",
  "description": "Determines whether this process is running.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Process.selectErrorStream

Source pointer: /19/method/7

```text
selectErrorStream([parameter metadata absent]): @IO.Stream
```

```json
{
  "name": "selectErrorStream",
  "description": "Selects the error stream of this process.",
  "return": [
    {
      "type": "@IO.Stream"
    }
  ]
}
```

## method: IO.Process.selectInputStream

Source pointer: /19/method/8

```text
selectInputStream([parameter metadata absent]): @IO.Stream
```

```json
{
  "name": "selectInputStream",
  "description": "Selects the input stream of this process.",
  "return": [
    {
      "type": "@IO.Stream"
    }
  ]
}
```

## method: IO.Process.selectOutputStream

Source pointer: /19/method/9

```text
selectOutputStream([parameter metadata absent]): @IO.Stream
```

```json
{
  "name": "selectOutputStream",
  "description": "Selects the output stream of this process.",
  "return": [
    {
      "type": "@IO.Stream"
    }
  ]
}
```

## method: IO.Process.terminate

Source pointer: /19/method/10

```text
terminate(int $signal): bool
```

```json
{
  "name": "terminate",
  "description": "Terminates this process without blocking by signaling a termination request.",
  "param": [
    {
      "name": "signal",
      "type": "int",
      "default": "15"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Process.toString

Source pointer: /19/method/11

```text
toString([parameter metadata absent]): string
```

```json
{
  "name": "toString",
  "description": "Converts this process to a string by returning the command that created it.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: IO.SocketClient

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/20
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.SocketClient

Source pointer: /20

```json
{
  "name": "IO.SocketClient",
  "static": false,
  "extend": "IO.SocketStream",
  "description": "IO socket client prototype."
}
```

## method: IO.SocketClient.construct

Source pointer: /20/method/0

```text
construct(string $endpoint, int $timeout)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "endpoint",
      "type": "string"
    },
    {
      "name": "timeout",
      "type": "int",
      "default": "60"
    }
  ]
}
```

# Zymba reference: IO.SocketServer

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/21
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.SocketServer

Source pointer: /21

```json
{
  "name": "IO.SocketServer",
  "static": false,
  "extend": "IO.SocketStream",
  "description": "IO socket server prototype."
}
```

## method: IO.SocketServer.construct

Source pointer: /21/method/0

```text
construct(string $endpoint)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "endpoint",
      "type": "string"
    }
  ]
}
```

## method: IO.SocketServer.accept

Source pointer: /21/method/1

```text
accept(int $timeout): @IO.SocketStream
```

```json
{
  "name": "accept",
  "param": [
    {
      "name": "timeout",
      "type": "int",
      "default": "60"
    }
  ],
  "return": [
    {
      "type": "@IO.SocketStream"
    }
  ]
}
```

# Zymba reference: IO.SocketStream

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/22
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.SocketStream

Source pointer: /22

```json
{
  "name": "IO.SocketStream",
  "static": false,
  "extend": "IO.Stream",
  "description": "Abstract IO socket stream prototype."
}
```

## method: IO.SocketStream.disableEncryption

Source pointer: /22/method/0

```text
disableEncryption([parameter metadata absent]): this
```

```json
{
  "name": "disableEncryption",
  "annotation": [
    "This function is complementary to \"enableEncryption\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.SocketStream.enableEncryption

Source pointer: /22/method/1

```text
enableEncryption([parameter metadata absent]): this
```

```json
{
  "name": "enableEncryption",
  "annotation": [
    "This function is complementary to \"disableEncryption\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.SocketStream.getLocalEndpoint

Source pointer: /22/method/2

```text
getLocalEndpoint([parameter metadata absent]): string
```

```json
{
  "name": "getLocalEndpoint",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.SocketStream.getRemoteEndpoint

Source pointer: /22/method/3

```text
getRemoteEndpoint([parameter metadata absent]): string
```

```json
{
  "name": "getRemoteEndpoint",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.SocketStream.peek

Source pointer: /22/method/4

```text
peek(int $length): string
```

```json
{
  "name": "peek",
  "param": [
    {
      "name": "length",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.SocketStream.receive

Source pointer: /22/method/5

```text
receive(int $length): object | null
```

```json
{
  "name": "receive",
  "param": [
    {
      "name": "length",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[string, endpoint]"
    },
    {
      "type": "null",
      "description": "if there is nothing to receive"
    }
  ]
}
```

## method: IO.SocketStream.receiveOutOfBand

Source pointer: /22/method/6

```text
receiveOutOfBand(int $length): object | null
```

```json
{
  "name": "receiveOutOfBand",
  "param": [
    {
      "name": "length",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[string, endpoint]"
    },
    {
      "type": "null",
      "description": "if there is nothing to receive"
    }
  ]
}
```

## method: IO.SocketStream.send

Source pointer: /22/method/7

```text
send(string $string, string $endpoint): int
```

```json
{
  "name": "send",
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "endpoint",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.SocketStream.sendOutOfBand

Source pointer: /22/method/8

```text
sendOutOfBand(string $string, string $endpoint): int
```

```json
{
  "name": "sendOutOfBand",
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "endpoint",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.SocketStream.shutdownReceive

Source pointer: /22/method/9

```text
shutdownReceive([parameter metadata absent]): this
```

```json
{
  "name": "shutdownReceive",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.SocketStream.shutdownSend

Source pointer: /22/method/10

```text
shutdownSend([parameter metadata absent]): this
```

```json
{
  "name": "shutdownSend",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: IO.Stream

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/23
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: IO.Stream

Source pointer: /23

```json
{
  "name": "IO.Stream",
  "static": false,
  "extend": "Base",
  "description": "Abstract IO stream prototype."
}
```

## method: IO.Stream.canRead

Source pointer: /23/method/0

```text
canRead([parameter metadata absent]): bool
```

```json
{
  "name": "canRead",
  "description": "Determines whether this stream can be read from.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.canSeek

Source pointer: /23/method/1

```text
canSeek([parameter metadata absent]): bool
```

```json
{
  "name": "canSeek",
  "description": "Determines whether this stream can be sought.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.canWrite

Source pointer: /23/method/2

```text
canWrite([parameter metadata absent]): bool
```

```json
{
  "name": "canWrite",
  "description": "Determines whether this stream can be written to.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.close

Source pointer: /23/method/3

```text
close([parameter metadata absent])
```

```json
{
  "name": "close",
  "description": "Closes this stream and frees its associated resources."
}
```

## method: IO.Stream.copyTo

Source pointer: /23/method/4

```text
copyTo(@IO.Stream $stream, ?int $length): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.disableBlocking

Source pointer: /23/method/5

```text
disableBlocking([parameter metadata absent]): this
```

```json
{
  "name": "disableBlocking",
  "description": "Disables blocking mode for this stream.",
  "annotation": [
    "This function is complementary to \"enableBlocking\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.echo

Source pointer: /23/method/6

```text
echo(?int $length): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.echoAll

Source pointer: /23/method/7

```text
echoAll([parameter metadata absent]): int
```

```json
{
  "name": "echoAll",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Stream.echoLine

Source pointer: /23/method/8

```text
echoLine([parameter metadata absent]): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.enableBlocking

Source pointer: /23/method/9

```text
enableBlocking([parameter metadata absent]): this
```

```json
{
  "name": "enableBlocking",
  "description": "Enables blocking mode for this stream.",
  "annotation": [
    "This function is complementary to \"disableBlocking\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.exit

Source pointer: /23/method/10

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit",
  "description": "Closes this stream and frees its associated resources for the purpose of contextualization."
}
```

## method: IO.Stream.flush

Source pointer: /23/method/11

```text
flush([parameter metadata absent]): this
```

```json
{
  "name": "flush",
  "description": "Flushes the write buffer of this stream.",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.getPosition

Source pointer: /23/method/12

```text
getPosition([parameter metadata absent]): int
```

```json
{
  "name": "getPosition",
  "description": "Gets the current position within this stream as the number of bytes from its beginning.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Stream.getURI

Source pointer: /23/method/13

```text
getURI([parameter metadata absent]): string
```

```json
{
  "name": "getURI",
  "description": "Gets the URI associated with this stream.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.Stream.hasMore

Source pointer: /23/method/14

```text
hasMore([parameter metadata absent]): bool
```

```json
{
  "name": "hasMore",
  "description": "Determines whether this stream has more content.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.hasTimedOut

Source pointer: /23/method/15

```text
hasTimedOut([parameter metadata absent]): bool
```

```json
{
  "name": "hasTimedOut",
  "description": "Determines whether this stream has timed out.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.isBlocking

Source pointer: /23/method/16

```text
isBlocking([parameter metadata absent]): bool
```

```json
{
  "name": "isBlocking",
  "description": "Determines whether this stream is in blocking mode.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.isLocal

Source pointer: /23/method/17

```text
isLocal([parameter metadata absent]): bool
```

```json
{
  "name": "isLocal",
  "description": "Determines whether this stream is local.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.next

Source pointer: /23/method/18

```text
next([parameter metadata absent]): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.overwrite

Source pointer: /23/method/19

```text
overwrite(string $string): int
```

```json
{
  "name": "overwrite",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: IO.Stream.pollExceptional

Source pointer: /23/method/20

```text
pollExceptional([parameter metadata absent]): bool
```

```json
{
  "name": "pollExceptional",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.pollRead

Source pointer: /23/method/21

```text
pollRead([parameter metadata absent]): bool
```

```json
{
  "name": "pollRead",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.pollWrite

Source pointer: /23/method/22

```text
pollWrite([parameter metadata absent]): bool
```

```json
{
  "name": "pollWrite",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: IO.Stream.read

Source pointer: /23/method/23

```text
read(?int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.readAll

Source pointer: /23/method/24

```text
readAll([parameter metadata absent]): string
```

```json
{
  "name": "readAll",
  "description": "Reads the entire content of this stream.",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.Stream.readLine

Source pointer: /23/method/25

```text
readLine([parameter metadata absent]): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.readLineCSV

Source pointer: /23/method/26

```text
readLineCSV(string $delimiter): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.reset

Source pointer: /23/method/27

```text
reset([parameter metadata absent]): this
```

```json
{
  "name": "reset",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.seek

Source pointer: /23/method/28

```text
seek(int $position): this
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.seekEnd

Source pointer: /23/method/29

```text
seekEnd([parameter metadata absent]): this
```

```json
{
  "name": "seekEnd",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.setReadBuffer

Source pointer: /23/method/30

```text
setReadBuffer(int $size): this
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.setTimeout

Source pointer: /23/method/31

```text
setTimeout(int $timeout): this
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.setWriteBuffer

Source pointer: /23/method/32

```text
setWriteBuffer(int $size): this
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.skip

Source pointer: /23/method/33

```text
skip(int $offset): this
```

```json
{
  "name": "skip",
  "annotation": [
    "This function may alter the position within the stream."
  ],
  "param": [
    {
      "name": "offset",
      "type": "int",
      "default": "1"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.toString

Source pointer: /23/method/34

```text
toString([parameter metadata absent]): string
```

```json
{
  "name": "toString",
  "description": "Converts this stream to a string by returning its associated URI.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: IO.Stream.truncate

Source pointer: /23/method/35

```text
truncate(int $size): this
```

```json
{
  "name": "truncate",
  "description": "Truncates this stream to a specific size in number of bytes.",
  "param": [
    {
      "name": "size",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: IO.Stream.write

Source pointer: /23/method/36

```text
write(string $string, ?int $length): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.writeFormatted

Source pointer: /23/method/37

```text
writeFormatted(string $format, variadic $arguments): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.writeLine

Source pointer: /23/method/38

```text
writeLine(string $string): int
```

```json
{
  "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"
    }
  ]
}
```

## method: IO.Stream.writeLineCSV

Source pointer: /23/method/39

```text
writeLineCSV(object $array, string $delimiter): int
```

```json
{
  "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"
    }
  ]
}
```

## constant: IO.Stream.MODE_READ

Source pointer: /23/const/0

```json
{
  "name": "MODE_READ",
  "type": "int",
  "description": "Stream read mode"
}
```

## constant: IO.Stream.MODE_WRITE

Source pointer: /23/const/1

```json
{
  "name": "MODE_WRITE",
  "type": "int",
  "description": "Stream write mode"
}
```

# Zymba reference: MIME

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/24
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: MIME

Source pointer: /24

```json
{
  "name": "MIME",
  "static": true,
  "description": "Static MIME related functions."
}
```

## method: MIME.createMultipart

Source pointer: /24/method/0

```text
createMultipart(object $parts, string $boundary, string $preamble, string $epilog): string
```

```json
{
  "name": "createMultipart",
  "param": [
    {
      "name": "parts",
      "type": "object"
    },
    {
      "name": "boundary",
      "type": "string"
    },
    {
      "name": "preamble",
      "type": "string"
    },
    {
      "name": "epilog",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: MIME.fromBase64

Source pointer: /24/method/1

```text
fromBase64(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.fromBase64URL

Source pointer: /24/method/2

```text
fromBase64URL(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.fromEncodedWord

Source pointer: /24/method/3

```text
fromEncodedWord(string $string): string
```

```json
{
  "name": "fromEncodedWord",
  "annotation": [
    "This function is complementary to \"toEncodedWord\"."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: MIME.fromQuotedPrintable

Source pointer: /24/method/4

```text
fromQuotedPrintable(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.isPrintable

Source pointer: /24/method/5

```text
isPrintable(string $string): bool
```

```json
{
  "name": "isPrintable",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: MIME.parseMultipart

Source pointer: /24/method/6

```text
parseMultipart(string $body, ?string $boundary): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.toBase64

Source pointer: /24/method/7

```text
toBase64(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.toBase64Raw

Source pointer: /24/method/8

```text
toBase64Raw(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.toBase64URL

Source pointer: /24/method/9

```text
toBase64URL(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: MIME.toEncodedWord

Source pointer: /24/method/10

```text
toEncodedWord(string $string): string
```

```json
{
  "name": "toEncodedWord",
  "annotation": [
    "This function is complementary to \"fromEncodedWord\"."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: MIME.toQuotedPrintable

Source pointer: /24/method/11

```text
toQuotedPrintable(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: Mail

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/25
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Mail

Source pointer: /25

```json
{
  "name": "Mail",
  "static": true,
  "description": "Static mail related prototypes and functions."
}
```

## method: Mail.isValidAddress

Source pointer: /25/method/0

```text
isValidAddress(string $address): bool
```

```json
{
  "name": "isValidAddress",
  "param": [
    {
      "name": "address",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Mail.parseMessage

Source pointer: /25/method/1

```text
parseMessage(string $message): @Mail.Message
```

```json
{
  "name": "parseMessage",
  "param": [
    {
      "name": "message",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "@Mail.Message"
    }
  ]
}
```

# Zymba reference: Mail.Message

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/26
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Mail.Message

Source pointer: /26

```json
{
  "name": "Mail.Message",
  "static": false,
  "extend": "Base",
  "description": "Abstract mail message prototype."
}
```

## method: Mail.Message.clearHeaders

Source pointer: /26/method/0

```text
clearHeaders([parameter metadata absent]): this
```

```json
{
  "name": "clearHeaders",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.countHeaders

Source pointer: /26/method/1

```text
countHeaders([parameter metadata absent]): int
```

```json
{
  "name": "countHeaders",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Mail.Message.create

Source pointer: /26/method/2

```text
create([parameter metadata absent]): string
```

```json
{
  "name": "create",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.Message.getDisposition

Source pointer: /26/method/3

```text
getDisposition([parameter metadata absent]): string
```

```json
{
  "name": "getDisposition",
  "description": "Gets the content disposition of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.Message.getFilename

Source pointer: /26/method/4

```text
getFilename([parameter metadata absent]): string
```

```json
{
  "name": "getFilename",
  "description": "Gets the filename of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.Message.getHeader

Source pointer: /26/method/5

```text
getHeader(string $name): string | object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Mail.Message.getTransferEncoding

Source pointer: /26/method/6

```text
getTransferEncoding([parameter metadata absent]): string
```

```json
{
  "name": "getTransferEncoding",
  "description": "Gets the content transfer encoding of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.Message.getType

Source pointer: /26/method/7

```text
getType([parameter metadata absent]): string
```

```json
{
  "name": "getType",
  "description": "Gets the content type of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.Message.isAttachment

Source pointer: /26/method/8

```text
isAttachment([parameter metadata absent]): bool
```

```json
{
  "name": "isAttachment",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Mail.Message.listHeaderNames

Source pointer: /26/method/9

```text
listHeaderNames([parameter metadata absent]): object
```

```json
{
  "name": "listHeaderNames",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: Mail.Message.listHeaders

Source pointer: /26/method/10

```text
listHeaders([parameter metadata absent]): object
```

```json
{
  "name": "listHeaders",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: Mail.Message.removeHeader

Source pointer: /26/method/11

```text
removeHeader(string $name): this
```

```json
{
  "name": "removeHeader",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.removeHeaders

Source pointer: /26/method/12

```text
removeHeaders(object $names): this
```

```json
{
  "name": "removeHeaders",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.setHeader

Source pointer: /26/method/13

```text
setHeader(string $name, mixed $value): this
```

```json
{
  "name": "setHeader",
  "description": "Sets a mail header.",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.setHeaders

Source pointer: /26/method/14

```text
setHeaders(object $headers, string $prefix): this
```

```json
{
  "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"
    }
  ]
}
```

## method: Mail.Message.setDisposition

Source pointer: /26/method/15

```text
setDisposition(string $disposition, string $filename): this
```

```json
{
  "name": "setDisposition",
  "description": "Sets the content disposition of this message.",
  "param": [
    {
      "name": "disposition",
      "type": "string"
    },
    {
      "name": "filename",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.setTransferEncoding

Source pointer: /26/method/16

```text
setTransferEncoding(string $encoding): this
```

```json
{
  "name": "setTransferEncoding",
  "description": "Sets the content transfer encoding of this message.",
  "param": [
    {
      "name": "encoding",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.Message.setType

Source pointer: /26/method/17

```text
setType(string $type): this
```

```json
{
  "name": "setType",
  "description": "Sets the content type of this message.",
  "param": [
    {
      "name": "type",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: Mail.MultipartMessage

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/27
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Mail.MultipartMessage

Source pointer: /27

```json
{
  "name": "Mail.MultipartMessage",
  "static": false,
  "extend": "Mail.Message",
  "description": "Multipart mail message prototype."
}
```

## method: Mail.MultipartMessage.construct

Source pointer: /27/method/0

```text
construct([parameter metadata absent])
```

```json
{
  "name": "construct"
}
```

## method: Mail.MultipartMessage.addPart

Source pointer: /27/method/1

```text
addPart(@Mail.Message $message): this
```

```json
{
  "name": "addPart",
  "param": [
    {
      "name": "message",
      "type": "@Mail.Message"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.MultipartMessage.attach

Source pointer: /27/method/2

```text
attach(string $string, string $filename, string $type): @Mail.SimpleMessage
```

```json
{
  "name": "attach",
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "filename",
      "type": "string"
    },
    {
      "name": "type",
      "type": "string",
      "default": "\"application/octet-stream\""
    }
  ],
  "return": [
    {
      "type": "@Mail.SimpleMessage"
    }
  ]
}
```

## method: Mail.MultipartMessage.attachFile

Source pointer: /27/method/3

```text
attachFile(string $path, ?string $filename, string $type): @Mail.SimpleMessage
```

```json
{
  "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"
    }
  ]
}
```

## method: Mail.MultipartMessage.clearParts

Source pointer: /27/method/4

```text
clearParts([parameter metadata absent]): this
```

```json
{
  "name": "clearParts",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.MultipartMessage.countParts

Source pointer: /27/method/5

```text
countParts([parameter metadata absent]): int
```

```json
{
  "name": "countParts",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Mail.MultipartMessage.getBoundary

Source pointer: /27/method/6

```text
getBoundary([parameter metadata absent]): string
```

```json
{
  "name": "getBoundary",
  "description": "Gets the boundary delimiter of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.MultipartMessage.listParts

Source pointer: /27/method/7

```text
listParts([parameter metadata absent]): object
```

```json
{
  "name": "listParts",
  "return": [
    {
      "type": "object",
      "value": "[message, ...]"
    }
  ]
}
```

## method: Mail.MultipartMessage.removePart

Source pointer: /27/method/8

```text
removePart(@Mail.Message $message): this
```

```json
{
  "name": "removePart",
  "param": [
    {
      "name": "message",
      "type": "@Mail.Message"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.MultipartMessage.setBoundary

Source pointer: /27/method/9

```text
setBoundary(string $boundary): this
```

```json
{
  "name": "setBoundary",
  "description": "Sets the boundary delimiter of this message.",
  "param": [
    {
      "name": "boundary",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: Mail.SimpleMessage

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/28
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Mail.SimpleMessage

Source pointer: /28

```json
{
  "name": "Mail.SimpleMessage",
  "static": false,
  "extend": "Mail.Message",
  "description": "Simple mail message prototype."
}
```

## method: Mail.SimpleMessage.construct

Source pointer: /28/method/0

```text
construct([parameter metadata absent])
```

```json
{
  "name": "construct"
}
```

## method: Mail.SimpleMessage.getBody

Source pointer: /28/method/1

```text
getBody([parameter metadata absent]): string
```

```json
{
  "name": "getBody",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.SimpleMessage.getBodyRaw

Source pointer: /28/method/2

```text
getBodyRaw([parameter metadata absent]): string
```

```json
{
  "name": "getBodyRaw",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.SimpleMessage.getCharset

Source pointer: /28/method/3

```text
getCharset([parameter metadata absent]): string
```

```json
{
  "name": "getCharset",
  "description": "Gets the character set of this message.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Mail.SimpleMessage.isText

Source pointer: /28/method/4

```text
isText([parameter metadata absent]): bool
```

```json
{
  "name": "isText",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Mail.SimpleMessage.setBody

Source pointer: /28/method/5

```text
setBody(string $body, ?string $encoding): this
```

```json
{
  "name": "setBody",
  "param": [
    {
      "name": "body",
      "type": "string"
    },
    {
      "name": "encoding",
      "type": "?string",
      "default": "current encoding"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.SimpleMessage.setBodyRaw

Source pointer: /28/method/6

```text
setBodyRaw(string $body): this
```

```json
{
  "name": "setBodyRaw",
  "param": [
    {
      "name": "body",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.SimpleMessage.setCharset

Source pointer: /28/method/7

```text
setCharset(string $charset): this
```

```json
{
  "name": "setCharset",
  "param": [
    {
      "name": "charset",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: Mail.SimpleMessage.setText

Source pointer: /28/method/8

```text
setText(string $text, ?string $charset): this
```

```json
{
  "name": "setText",
  "param": [
    {
      "name": "text",
      "type": "string"
    },
    {
      "name": "charset",
      "type": "?string",
      "default": "current charset or UTF-8 if empty"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: Math

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/29
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Math

Source pointer: /29

```json
{
  "name": "Math",
  "static": true,
  "description": "Static mathematical constants and functions."
}
```

## method: Math.abs

Source pointer: /29/method/0

```text
abs(number $x): number
```

```json
{
  "name": "abs",
  "description": "Returns the absolute value of a number.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "number"
    }
  ]
}
```

## method: Math.acos

Source pointer: /29/method/1

```text
acos(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.acosh

Source pointer: /29/method/2

```text
acosh(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.acot

Source pointer: /29/method/3

```text
acot(number $x): float
```

```json
{
  "name": "acot",
  "description": "Calculates the inverse cotangent of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.acoth

Source pointer: /29/method/4

```text
acoth(number $x): float | float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.acsc

Source pointer: /29/method/5

```text
acsc(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.acsch

Source pointer: /29/method/6

```text
acsch(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.add

Source pointer: /29/method/7

```text
add(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.alice

Source pointer: /29/method/8

```text
alice([parameter metadata absent]): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.asec

Source pointer: /29/method/9

```text
asec(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.asech

Source pointer: /29/method/10

```text
asech(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.asin

Source pointer: /29/method/11

```text
asin(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.asinh

Source pointer: /29/method/12

```text
asinh(number $x): float
```

```json
{
  "name": "asinh",
  "description": "Calculates the inverse hyperbolic sine of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.atan

Source pointer: /29/method/13

```text
atan(number $x): float
```

```json
{
  "name": "atan",
  "description": "Calculates the inverse tangent of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.atan2

Source pointer: /29/method/14

```text
atan2(number $x, number $y): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.atanh

Source pointer: /29/method/15

```text
atanh(number $x): float | float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.bob

Source pointer: /29/method/16

```text
bob([parameter metadata absent]): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.cbrt

Source pointer: /29/method/17

```text
cbrt(number $x): float
```

```json
{
  "name": "cbrt",
  "description": "Calculates the principal cube root of a number.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.ceil

Source pointer: /29/method/18

```text
ceil(number $x): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.cos

Source pointer: /29/method/19

```text
cos(number $x): float
```

```json
{
  "name": "cos",
  "description": "Calculates the cosine of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.cosh

Source pointer: /29/method/20

```text
cosh(number $x): float
```

```json
{
  "name": "cosh",
  "description": "Calculates the hyperbolic cosine of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.cot

Source pointer: /29/method/21

```text
cot(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.coth

Source pointer: /29/method/22

```text
coth(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.csc

Source pointer: /29/method/23

```text
csc(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.csch

Source pointer: /29/method/24

```text
csch(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.dim

Source pointer: /29/method/25

```text
dim(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.div

Source pointer: /29/method/26

```text
div(number $x, number $y): number | float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.erf

Source pointer: /29/method/27

```text
erf(number $x): float
```

```json
{
  "name": "erf",
  "description": "Calculates the error function of a number using numerical approximation.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.euclideanMod

Source pointer: /29/method/28

```text
euclideanMod(number $x, number $y): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.exp

Source pointer: /29/method/29

```text
exp(number $x): float
```

```json
{
  "name": "exp",
  "description": "Raises Euler's constant to the power of an exponent (x).",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.expm1

Source pointer: /29/method/30

```text
expm1(number $x): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.fib

Source pointer: /29/method/31

```text
fib(number $x): float
```

```json
{
  "name": "fib",
  "description": "Calculates a specific Fibonacci number using Binet's formula.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.floor

Source pointer: /29/method/32

```text
floor(number $x): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.flooredMod

Source pointer: /29/method/33

```text
flooredMod(number $x, number $y): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.fromDegrees

Source pointer: /29/method/34

```text
fromDegrees(number $angle): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.gamma

Source pointer: /29/method/35

```text
gamma(number $x): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.gcd

Source pointer: /29/method/36

```text
gcd(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.hypot

Source pointer: /29/method/37

```text
hypot(number $x, number $y): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.ln

Source pointer: /29/method/38

```text
ln(number $x): float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.ln1p

Source pointer: /29/method/39

```text
ln1p(number $x): float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.log

Source pointer: /29/method/40

```text
log(number $x, number $y): float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.mod

Source pointer: /29/method/41

```text
mod(number $x, number $y): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.mul

Source pointer: /29/method/42

```text
mul(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.neg

Source pointer: /29/method/43

```text
neg(number $x): number
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.pow

Source pointer: /29/method/44

```text
pow(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.rand

Source pointer: /29/method/45

```text
rand([parameter metadata absent]): float
```

```json
{
  "name": "rand",
  "description": "Generates a pseudo-random number between zero and one using the Mersenne Twister algorithm.",
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.recip

Source pointer: /29/method/46

```text
recip(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.rem

Source pointer: /29/method/47

```text
rem(number $x, number $y): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.round

Source pointer: /29/method/48

```text
round(number $number): float
```

```json
{
  "name": "round",
  "description": "Rounds a number to nearest, ties to even as defined in IEEE 754.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.sec

Source pointer: /29/method/49

```text
sec(number $x): float
```

```json
{
  "name": "sec",
  "description": "Calculates the secant of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.sech

Source pointer: /29/method/50

```text
sech(number $x): float
```

```json
{
  "name": "sech",
  "description": "Calculates the hyperbolic secant of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.sgn

Source pointer: /29/method/51

```text
sgn(number $x): int | int | int | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.sin

Source pointer: /29/method/52

```text
sin(number $x): float
```

```json
{
  "name": "sin",
  "description": "Calculates the sine of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.sinh

Source pointer: /29/method/53

```text
sinh(number $x): float
```

```json
{
  "name": "sinh",
  "description": "Calculates the hyperbolic sine of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.sqr

Source pointer: /29/method/54

```text
sqr(number $x): number
```

```json
{
  "name": "sqr",
  "description": "Calculates the square of a number.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "number"
    }
  ]
}
```

## method: Math.sqrt

Source pointer: /29/method/55

```text
sqrt(number $x): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.sub

Source pointer: /29/method/56

```text
sub(number $x, number $y): number | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.tan

Source pointer: /29/method/57

```text
tan(number $x): float
```

```json
{
  "name": "tan",
  "description": "Calculates the tangent of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.tanh

Source pointer: /29/method/58

```text
tanh(number $x): float
```

```json
{
  "name": "tanh",
  "description": "Calculates the hyperbolic tangent of a number in radians.",
  "param": [
    {
      "name": "x",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: Math.toDegrees

Source pointer: /29/method/59

```text
toDegrees(number $angle): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.truncate

Source pointer: /29/method/60

```text
truncate(number $x): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Math.truncatedDiv

Source pointer: /29/method/61

```text
truncatedDiv(number $x, number $y): number | float | float | float
```

```json
{
  "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"
    }
  ]
}
```

## constant: Math.E

Source pointer: /29/const/0

```json
{
  "name": "E",
  "type": "float",
  "description": "Euler's number and the base of natural logarithms, approximately 2.718"
}
```

## constant: Math.LN2

Source pointer: /29/const/1

```json
{
  "name": "LN2",
  "type": "float",
  "description": "Natural logarithm of 2, approximately 0.693"
}
```

## constant: Math.LN10

Source pointer: /29/const/2

```json
{
  "name": "LN10",
  "type": "float",
  "description": "Natural logarithm of 10, approximately 2.303"
}
```

## constant: Math.LNPI

Source pointer: /29/const/3

```json
{
  "name": "LNPI",
  "type": "float",
  "description": "Natural logarithm of PI, approximately 1.145"
}
```

## constant: Math.LOG10E

Source pointer: /29/const/4

```json
{
  "name": "LOG10E",
  "type": "float",
  "description": "Base 10 logarithm of E, approximately 0.434"
}
```

## constant: Math.LOG2E

Source pointer: /29/const/5

```json
{
  "name": "LOG2E",
  "type": "float",
  "description": "Base 2 logarithm of E, approximately 1.443"
}
```

## constant: Math.PI

Source pointer: /29/const/6

```json
{
  "name": "PI",
  "type": "float",
  "description": "Ratio of the circumference of a circle to its diameter, approximately 3.142"
}
```

## constant: Math.SQRT2

Source pointer: /29/const/7

```json
{
  "name": "SQRT2",
  "type": "float",
  "description": "Square root of 2, approximately 1.414"
}
```

## constant: Math.SQRT3

Source pointer: /29/const/8

```json
{
  "name": "SQRT3",
  "type": "float",
  "description": "Square root of 3, approximately 1.732"
}
```

## constant: Math.SQRTPI

Source pointer: /29/const/9

```json
{
  "name": "SQRTPI",
  "type": "float",
  "description": "Square root of PI, approximately 1.772"
}
```

# Zymba reference: Number

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/30
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Number

Source pointer: /30

```json
{
  "name": "Number",
  "static": true,
  "description": "Static number related constants and functions."
}
```

## method: Number.compare

Source pointer: /30/method/0

```text
compare(number $number1, number $number2): int | int | int
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.countLeadingZeros

Source pointer: /30/method/1

```text
countLeadingZeros(int $number): int
```

```json
{
  "name": "countLeadingZeros",
  "description": "Counts the leading zeros of an unsigned integer number.",
  "param": [
    {
      "name": "number",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Number.equals

Source pointer: /30/method/2

```text
equals(number $number1, number $number2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.format

Source pointer: /30/method/3

```text
format(number $number, int $precision, string $point, string $separator): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.fromBinary

Source pointer: /30/method/4

```text
fromBinary(string $binary): number
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.fromHex

Source pointer: /30/method/5

```text
fromHex(string $hex): number
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.fromOctal

Source pointer: /30/method/6

```text
fromOctal(string $octal): number
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.hasFractionalPart

Source pointer: /30/method/7

```text
hasFractionalPart(number $number): bool
```

```json
{
  "name": "hasFractionalPart",
  "description": "Determines whether a number has a fractional part.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.hasIntegerPart

Source pointer: /30/method/8

```text
hasIntegerPart(number $number): bool
```

```json
{
  "name": "hasIntegerPart",
  "description": "Determines whether a number has an integer part.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isBigEndian

Source pointer: /30/method/9

```text
isBigEndian([parameter metadata absent]): bool
```

```json
{
  "name": "isBigEndian",
  "description": "Determines whether the machine is of a big-endian architecture.",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isEven

Source pointer: /30/method/10

```text
isEven(number $number): bool
```

```json
{
  "name": "isEven",
  "description": "Determines whether a number is even.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isFinite

Source pointer: /30/method/11

```text
isFinite(number $number): bool
```

```json
{
  "name": "isFinite",
  "description": "Determines whether a number is finite.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isInfinite

Source pointer: /30/method/12

```text
isInfinite(number $number): bool
```

```json
{
  "name": "isInfinite",
  "description": "Determines whether a number is infinite.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isNaN

Source pointer: /30/method/13

```text
isNaN(number $number): bool
```

```json
{
  "name": "isNaN",
  "description": "Determines whether a number is \"not a number\" (NaN).",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isNatural

Source pointer: /30/method/14

```text
isNatural(number $number): bool
```

```json
{
  "name": "isNatural",
  "description": "Determines whether a number is in the set of natural numbers including zero.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isNegative

Source pointer: /30/method/15

```text
isNegative(number $number): bool
```

```json
{
  "name": "isNegative",
  "description": "Determines whether a number is negative.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isOdd

Source pointer: /30/method/16

```text
isOdd(number $number): bool
```

```json
{
  "name": "isOdd",
  "description": "Determines whether a number is odd.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isPositive

Source pointer: /30/method/17

```text
isPositive(number $number): bool
```

```json
{
  "name": "isPositive",
  "description": "Determines whether a number is positive.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isPrime

Source pointer: /30/method/18

```text
isPrime(number $number): bool
```

```json
{
  "name": "isPrime",
  "description": "Determines whether a number is a prime number.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isSafeInteger

Source pointer: /30/method/19

```text
isSafeInteger(number $number): bool
```

```json
{
  "name": "isSafeInteger",
  "description": "Determines whether a number is a whole number within the safe integer range.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.isZero

Source pointer: /30/method/20

```text
isZero(number $number): bool
```

```json
{
  "name": "isZero",
  "description": "Determines whether a number equals zero.",
  "param": [
    {
      "name": "number",
      "type": "number"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Number.max

Source pointer: /30/method/21

```text
max(variadic $numbers): number | float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.min

Source pointer: /30/method/22

```text
min(variadic $numbers): number | float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.normalize

Source pointer: /30/method/23

```text
normalize(number $number): number
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.randomFloat

Source pointer: /30/method/24

```text
randomFloat(number $min, number $max): float | float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.randomInt

Source pointer: /30/method/25

```text
randomInt(int $min, int $max): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundDown

Source pointer: /30/method/26

```text
roundDown(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfDown

Source pointer: /30/method/27

```text
roundHalfDown(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfToEven

Source pointer: /30/method/28

```text
roundHalfToEven(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfToOdd

Source pointer: /30/method/29

```text
roundHalfToOdd(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfToInfinity

Source pointer: /30/method/30

```text
roundHalfToInfinity(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfToZero

Source pointer: /30/method/31

```text
roundHalfToZero(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundHalfUp

Source pointer: /30/method/32

```text
roundHalfUp(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundToInfinity

Source pointer: /30/method/33

```text
roundToInfinity(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundToZero

Source pointer: /30/method/34

```text
roundToZero(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.roundUp

Source pointer: /30/method/35

```text
roundUp(number $number, int $precision): float
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toBinary

Source pointer: /30/method/36

```text
toBinary(int $decimal): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toExponential

Source pointer: /30/method/37

```text
toExponential(number $number, int $digits): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toFixed

Source pointer: /30/method/38

```text
toFixed(number $number, int $digits): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toHex

Source pointer: /30/method/39

```text
toHex(int $decimal): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toOctal

Source pointer: /30/method/40

```text
toOctal(int $decimal): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Number.toPrecision

Source pointer: /30/method/41

```text
toPrecision(number $number, int $digits): string
```

```json
{
  "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"
    }
  ]
}
```

## constant: Number.EPSILON

Source pointer: /30/const/0

```json
{
  "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"
}
```

## constant: Number.INF

Source pointer: /30/const/1

```json
{
  "name": "INF",
  "type": "float",
  "description": "Special value representing infinity; returned on overflow"
}
```

## constant: Number.MINFLOAT

Source pointer: /30/const/2

```json
{
  "name": "MINFLOAT",
  "type": "float",
  "description": "Minimum value of type \"float\""
}
```

## constant: Number.MININT

Source pointer: /30/const/3

```json
{
  "name": "MININT",
  "type": "int",
  "description": "Minimum value of type \"int\""
}
```

## constant: Number.MAXFLOAT

Source pointer: /30/const/4

```json
{
  "name": "MAXFLOAT",
  "type": "float",
  "description": "Maximum value of type \"float\""
}
```

## constant: Number.MAXINT

Source pointer: /30/const/5

```json
{
  "name": "MAXINT",
  "type": "int",
  "description": "Maximum value of type \"int\""
}
```

## constant: Number.NAN

Source pointer: /30/const/6

```json
{
  "name": "NAN",
  "type": "float",
  "description": "Special \"not a number\" value"
}
```

# Zymba reference: Output

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/31
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Output

Source pointer: /31

```json
{
  "name": "Output",
  "static": true,
  "description": "Static standard output related prototypes and functions."
}
```

## method: Output.clear

Source pointer: /31/method/0

```text
clear([parameter metadata absent])
```

```json
{
  "name": "clear",
  "description": "Clears the output buffer."
}
```

## method: Output.echo

Source pointer: /31/method/1

```text
echo(variadic $strings)
```

```json
{
  "name": "echo",
  "description": "Outputs strings.",
  "annotation": [
    "This function is equivalent to the \"echo\" statement."
  ],
  "param": [
    {
      "name": "strings",
      "type": "variadic"
    }
  ]
}
```

## method: Output.flush

Source pointer: /31/method/2

```text
flush([parameter metadata absent])
```

```json
{
  "name": "flush",
  "description": "Flushes the output buffer."
}
```

## method: Output.getContent

Source pointer: /31/method/3

```text
getContent([parameter metadata absent]): string
```

```json
{
  "name": "getContent",
  "description": "Gets the content of the current output buffer.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Output.getLevel

Source pointer: /31/method/4

```text
getLevel([parameter metadata absent]): int
```

```json
{
  "name": "getLevel",
  "description": "Gets the nesting level of output buffering.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Output.getSize

Source pointer: /31/method/5

```text
getSize([parameter metadata absent]): int
```

```json
{
  "name": "getSize",
  "description": "Gets the size of the current output buffer in number of bytes.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

# Zymba reference: Path

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/32
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Path

Source pointer: /32

```json
{
  "name": "Path",
  "static": true,
  "description": "Static path related constants and functions."
}
```

## method: Path.fromURI

Source pointer: /32/method/0

```text
fromURI(string $uri): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Path.getBase

Source pointer: /32/method/1

```text
getBase(string $path): string
```

```json
{
  "name": "getBase",
  "description": "Gets the base name component of a path (including extension).",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.getDirectory

Source pointer: /32/method/2

```text
getDirectory(string $path): string
```

```json
{
  "name": "getDirectory",
  "description": "Gets the directory name component of a path.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.getExtension

Source pointer: /32/method/3

```text
getExtension(string $path): string
```

```json
{
  "name": "getExtension",
  "description": "Gets the file extension component of a path.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.getFile

Source pointer: /32/method/4

```text
getFile(string $path): string
```

```json
{
  "name": "getFile",
  "description": "Gets the filename component of a path (excluding extension).",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.getTempDirectory

Source pointer: /32/method/5

```text
getTempDirectory([parameter metadata absent]): string
```

```json
{
  "name": "getTempDirectory",
  "description": "Gets the absolute path of the system's directory for temporary files.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.getWorkingDirectory

Source pointer: /32/method/6

```text
getWorkingDirectory([parameter metadata absent]): string
```

```json
{
  "name": "getWorkingDirectory",
  "description": "Gets the absolute path of the current working directory.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.hasExtension

Source pointer: /32/method/7

```text
hasExtension(string $path): bool
```

```json
{
  "name": "hasExtension",
  "description": "Determines whether a path has a file extension component.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Path.isAbsolute

Source pointer: /32/method/8

```text
isAbsolute(string $path): bool
```

```json
{
  "name": "isAbsolute",
  "description": "Determines whether a path is absolute.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Path.normalize

Source pointer: /32/method/9

```text
normalize(string $path): string
```

```json
{
  "name": "normalize",
  "description": "Normalizes a path to its canonicalized representation.",
  "annotation": [
    "Removes dot-segments from path."
  ],
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.parse

Source pointer: /32/method/10

```text
parse(string $path): object
```

```json
{
  "name": "parse",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[\"directory\": ..., \"file\": ..., \"extension\": ...]"
    }
  ]
}
```

## method: Path.setWorkingDirectory

Source pointer: /32/method/11

```text
setWorkingDirectory(string $path)
```

```json
{
  "name": "setWorkingDirectory",
  "description": "Sets the path of the working directory.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ]
}
```

## method: Path.toAbsolutePath

Source pointer: /32/method/12

```text
toAbsolutePath(string $path): string
```

```json
{
  "name": "toAbsolutePath",
  "description": "Converts a path to its canonicalized absolute path.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Path.toRealPath

Source pointer: /32/method/13

```text
toRealPath(string $path): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Path.toURI

Source pointer: /32/method/14

```text
toURI(string $path): string
```

```json
{
  "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"
    }
  ]
}
```

## constant: Path.DIRECTORYSEPARATOR

Source pointer: /32/const/0

```json
{
  "name": "DIRECTORYSEPARATOR",
  "type": "string"
}
```

## constant: Path.MAXLENGTH

Source pointer: /32/const/1

```json
{
  "name": "MAXLENGTH",
  "type": "int"
}
```

## constant: Path.PATHSEPARATOR

Source pointer: /32/const/2

```json
{
  "name": "PATHSEPARATOR",
  "type": "string"
}
```

# Zymba reference: REST

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/33
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: REST

Source pointer: /33

```json
{
  "name": "REST",
  "static": true,
  "description": "Static RESTful related prototypes."
}
```

# Zymba reference: REST.Client

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/34
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: REST.Client

Source pointer: /34

```json
{
  "name": "REST.Client",
  "static": false,
  "extend": "Base",
  "description": "RESTful client prototype."
}
```

## method: REST.Client.construct

Source pointer: /34/method/0

```text
construct(string $url, ?function $callback_request, ?function $callback_response, int $timeout, bool $validate)
```

```json
{
  "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"
    }
  ]
}
```

## method: REST.Client.bind

Source pointer: /34/method/1

```text
bind(string $route, string $method, object $headers): function
```

```json
{
  "name": "bind",
  "param": [
    {
      "name": "route",
      "type": "string"
    },
    {
      "name": "method",
      "type": "string",
      "default": "\"GET\""
    },
    {
      "name": "headers",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "function"
    }
  ]
}
```

## method: REST.Client.call

Source pointer: /34/method/2

```text
call(string $route, string $method, object $headers, variadic $arguments): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: REST.Client.setLocation

Source pointer: /34/method/3

```text
setLocation(string $url): this
```

```json
{
  "name": "setLocation",
  "param": [
    {
      "name": "url",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: REST.Client.setTimeout

Source pointer: /34/method/4

```text
setTimeout(int $timeout): this
```

```json
{
  "name": "setTimeout",
  "param": [
    {
      "name": "timeout",
      "type": "int",
      "default": "60"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: REST.Client.setValidate

Source pointer: /34/method/5

```text
setValidate(bool $validate): this
```

```json
{
  "name": "setValidate",
  "param": [
    {
      "name": "validate",
      "type": "bool",
      "default": "true"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: REST.Server

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/35
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: REST.Server

Source pointer: /35

```json
{
  "name": "REST.Server",
  "static": false,
  "extend": "Base",
  "description": "RESTful server prototype."
}
```

## method: REST.Server.construct

Source pointer: /35/method/0

```text
construct([parameter metadata absent])
```

```json
{
  "name": "construct"
}
```

## method: REST.Server.bind

Source pointer: /35/method/1

```text
bind(function $callback, string $route, string $method): this
```

```json
{
  "name": "bind",
  "param": [
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "route",
      "type": "string"
    },
    {
      "name": "method",
      "type": "string",
      "default": "\"GET\""
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: REST.Server.bindMethods

Source pointer: /35/method/2

```text
bindMethods(variadic $routes): this
```

```json
{
  "name": "bindMethods",
  "param": [
    {
      "name": "routes",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: REST.Server.handle

Source pointer: /35/method/3

```text
handle([parameter metadata absent]): mixed
```

```json
{
  "name": "handle",
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

# Zymba reference: Regex

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/36
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Regex

Source pointer: /36

```json
{
  "name": "Regex",
  "static": true,
  "description": "Static regular expression functions."
}
```

## method: Regex.count

Source pointer: /36/method/0

```text
count(string $string, string $pattern, int $offset): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.escape

Source pointer: /36/method/1

```text
escape(string $string, string $delimiter): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.isValidPattern

Source pointer: /36/method/2

```text
isValidPattern(string $pattern): bool
```

```json
{
  "name": "isValidPattern",
  "description": "Determines whether a regular expression pattern is valid.",
  "param": [
    {
      "name": "pattern",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Regex.match

Source pointer: /36/method/3

```text
match(string $string, string $pattern, int $offset): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.matchAll

Source pointer: /36/method/4

```text
matchAll(string $string, string $pattern, int $offset): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.replace

Source pointer: /36/method/5

```text
replace(string $string, string $pattern, string $replacement, int $limit): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.replaceMultiple

Source pointer: /36/method/6

```text
replaceMultiple(string $string, object $replacements): string
```

```json
{
  "name": "replaceMultiple",
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "replacements",
      "type": "object",
      "value": "[pattern: replacement, ...]"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Regex.split

Source pointer: /36/method/7

```text
split(string $string, string $pattern, int $limit): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Regex.splitNonEmpty

Source pointer: /36/method/8

```text
splitNonEmpty(string $string, string $pattern, int $limit): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Regex.substitute

Source pointer: /36/method/9

```text
substitute(string $string, string $pattern, function $callback, ?object $bind, int $limit): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Regex.test

Source pointer: /36/method/10

```text
test(string $string, string $pattern, int $offset): bool
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: SOAP

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/37
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SOAP

Source pointer: /37

```json
{
  "name": "SOAP",
  "static": true,
  "description": "Static SOAP related prototypes."
}
```

# Zymba reference: SOAP.Client

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/38
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SOAP.Client

Source pointer: /38

```json
{
  "name": "SOAP.Client",
  "static": false,
  "extend": "Base",
  "description": "SOAP client prototype."
}
```

## method: SOAP.Client.construct

Source pointer: /38/method/0

```text
construct(string $wsdl, string $username, string $password, int $timeout)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "wsdl",
      "type": "string"
    },
    {
      "name": "username",
      "type": "string"
    },
    {
      "name": "password",
      "type": "string"
    },
    {
      "name": "timeout",
      "type": "int",
      "default": "60"
    }
  ]
}
```

## method: SOAP.Client.bind

Source pointer: /38/method/1

```text
bind(string $operation): function
```

```json
{
  "name": "bind",
  "param": [
    {
      "name": "operation",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "function"
    }
  ]
}
```

## method: SOAP.Client.call

Source pointer: /38/method/2

```text
call(string $operation, variadic $arguments): mixed
```

```json
{
  "name": "call",
  "param": [
    {
      "name": "operation",
      "type": "string"
    },
    {
      "name": "arguments",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: SOAP.Client.listOperations

Source pointer: /38/method/3

```text
listOperations([parameter metadata absent]): object
```

```json
{
  "name": "listOperations",
  "return": [
    {
      "type": "object",
      "value": "[signature, ...]"
    }
  ]
}
```

## method: SOAP.Client.listTypes

Source pointer: /38/method/4

```text
listTypes([parameter metadata absent]): object
```

```json
{
  "name": "listTypes",
  "return": [
    {
      "type": "object",
      "value": "[signature, ...]"
    }
  ]
}
```

## method: SOAP.Client.setCookie

Source pointer: /38/method/5

```text
setCookie(string $name, string $value): this
```

```json
{
  "name": "setCookie",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SOAP.Client.setLocation

Source pointer: /38/method/6

```text
setLocation(string $url): this
```

```json
{
  "name": "setLocation",
  "param": [
    {
      "name": "url",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SOAP.Client.setTimeout

Source pointer: /38/method/7

```text
setTimeout(int $timeout): this
```

```json
{
  "name": "setTimeout",
  "param": [
    {
      "name": "timeout",
      "type": "int",
      "default": "60"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: SOAP.Server

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/39
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SOAP.Server

Source pointer: /39

```json
{
  "name": "SOAP.Server",
  "static": false,
  "extend": "Base",
  "description": "SOAP server prototype."
}
```

## method: SOAP.Server.construct

Source pointer: /39/method/0

```text
construct(string $wsdl)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "wsdl",
      "type": "string"
    }
  ]
}
```

## method: SOAP.Server.bind

Source pointer: /39/method/1

```text
bind(function $callback, string $operation): this
```

```json
{
  "name": "bind",
  "param": [
    {
      "name": "callback",
      "type": "function"
    },
    {
      "name": "operation",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SOAP.Server.bindMethods

Source pointer: /39/method/2

```text
bindMethods(variadic $operations): this
```

```json
{
  "name": "bindMethods",
  "param": [
    {
      "name": "operations",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SOAP.Server.handle

Source pointer: /39/method/3

```text
handle([parameter metadata absent])
```

```json
{
  "name": "handle"
}
```

# Zymba reference: SQL

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/40
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL

Source pointer: /40

```json
{
  "name": "SQL",
  "static": true,
  "description": "Static SQL related prototypes and functions."
}
```

## method: SQL.createSearchCondition

Source pointer: /40/method/0

```text
createSearchCondition(string $query, variadic $fields): string
```

```json
{
  "name": "createSearchCondition",
  "param": [
    {
      "name": "query",
      "type": "string"
    },
    {
      "name": "fields",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.prepare

Source pointer: /40/method/1

```text
prepare(string $query, variadic $arguments): string
```

```json
{
  "name": "prepare",
  "param": [
    {
      "name": "query",
      "type": "string"
    },
    {
      "name": "arguments",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.quoteIdentifier

Source pointer: /40/method/2

```text
quoteIdentifier(variadic $identifiers): string
```

```json
{
  "name": "quoteIdentifier",
  "param": [
    {
      "name": "identifiers",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.quoteLiteral

Source pointer: /40/method/3

```text
quoteLiteral(variadic $literals): string
```

```json
{
  "name": "quoteLiteral",
  "param": [
    {
      "name": "literals",
      "type": "variadic"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: SQL.Connection

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/41
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.Connection

Source pointer: /41

```json
{
  "name": "SQL.Connection",
  "static": false,
  "extend": "Base",
  "description": "Abstract SQL connection prototype."
}
```

## method: SQL.Connection.begin

Source pointer: /41/method/0

```text
begin([parameter metadata absent]): this
```

```json
{
  "name": "begin",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.close

Source pointer: /41/method/1

```text
close([parameter metadata absent])
```

```json
{
  "name": "close",
  "description": "Closes this connection and frees its associated resources."
}
```

## method: SQL.Connection.commit

Source pointer: /41/method/2

```text
commit([parameter metadata absent]): this
```

```json
{
  "name": "commit",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.countAffectedRows

Source pointer: /41/method/3

```text
countAffectedRows([parameter metadata absent]): int
```

```json
{
  "name": "countAffectedRows",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.countRowsInTable

Source pointer: /41/method/4

```text
countRowsInTable(string $table): int
```

```json
{
  "name": "countRowsInTable",
  "param": [
    {
      "name": "table",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.delete

Source pointer: /41/method/5

```text
delete(string $table, object $conditions): int
```

```json
{
  "name": "delete",
  "param": [
    {
      "name": "table",
      "type": "string"
    },
    {
      "name": "conditions",
      "type": "object",
      "value": "[field: value, ...]"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.exists

Source pointer: /41/method/6

```text
exists(string $table, object $conditions): bool
```

```json
{
  "name": "exists",
  "param": [
    {
      "name": "table",
      "type": "string"
    },
    {
      "name": "conditions",
      "type": "object",
      "value": "[field: value, ...]"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: SQL.Connection.exit

Source pointer: /41/method/7

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit",
  "description": "Closes this connection and frees its associated resources for the purpose of contextualization."
}
```

## method: SQL.Connection.fetchAll

Source pointer: /41/method/8

```text
fetchAll(string $query, bool $indexed): object
```

```json
{
  "name": "fetchAll",
  "param": [
    {
      "name": "query",
      "type": "string"
    },
    {
      "name": "indexed",
      "type": "bool",
      "default": "false"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[row, ...]"
    }
  ]
}
```

## method: SQL.Connection.fetchAllOfField

Source pointer: /41/method/9

```text
fetchAllOfField(string $query, int $index): object
```

```json
{
  "name": "fetchAllOfField",
  "param": [
    {
      "name": "query",
      "type": "string"
    },
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[value, ...]"
    }
  ]
}
```

## method: SQL.Connection.fetchOne

Source pointer: /41/method/10

```text
fetchOne(string $query, bool $indexed): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.Connection.getCharset

Source pointer: /41/method/11

```text
getCharset([parameter metadata absent]): string
```

```json
{
  "name": "getCharset",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.Connection.getDatabaseName

Source pointer: /41/method/12

```text
getDatabaseName([parameter metadata absent]): string
```

```json
{
  "name": "getDatabaseName",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.Connection.getDatabaseSize

Source pointer: /41/method/13

```text
getDatabaseSize([parameter metadata absent]): int
```

```json
{
  "name": "getDatabaseSize",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.getLastInsertID

Source pointer: /41/method/14

```text
getLastInsertID([parameter metadata absent]): int
```

```json
{
  "name": "getLastInsertID",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.getVersion

Source pointer: /41/method/15

```text
getVersion([parameter metadata absent]): string
```

```json
{
  "name": "getVersion",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.Connection.insert

Source pointer: /41/method/16

```text
insert(string $table, object $data): int
```

```json
{
  "name": "insert",
  "param": [
    {
      "name": "table",
      "type": "string"
    },
    {
      "name": "data",
      "type": "object",
      "value": "[field: value, ...]"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.listFieldsInTable

Source pointer: /41/method/17

```text
listFieldsInTable(string $table): object
```

```json
{
  "name": "listFieldsInTable",
  "param": [
    {
      "name": "table",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[field, ...]"
    }
  ]
}
```

## method: SQL.Connection.listTables

Source pointer: /41/method/18

```text
listTables([parameter metadata absent]): object
```

```json
{
  "name": "listTables",
  "return": [
    {
      "type": "object",
      "value": "[table, ...]"
    }
  ]
}
```

## method: SQL.Connection.query

Source pointer: /41/method/19

```text
query(string $query): object | null
```

```json
{
  "name": "query",
  "param": [
    {
      "name": "query",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "SQL.ResultSet"
    },
    {
      "type": "null",
      "description": "if the query is a non-SELECT"
    }
  ]
}
```

## method: SQL.Connection.releaseSavepoint

Source pointer: /41/method/20

```text
releaseSavepoint(string $name): this
```

```json
{
  "name": "releaseSavepoint",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.rollback

Source pointer: /41/method/21

```text
rollback([parameter metadata absent]): this
```

```json
{
  "name": "rollback",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.rollbackToSavepoint

Source pointer: /41/method/22

```text
rollbackToSavepoint(string $name): this
```

```json
{
  "name": "rollbackToSavepoint",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.savepoint

Source pointer: /41/method/23

```text
savepoint(string $name): this
```

```json
{
  "name": "savepoint",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.selectAll

Source pointer: /41/method/24

```text
selectAll(string $table, object $fields, object $conditions, object $orderby, int $limit, int $offset, bool $indexed): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: SQL.Connection.selectAllOfField

Source pointer: /41/method/25

```text
selectAllOfField(string $table, string $field, object $conditions, object $orderby, int $limit, int $offset): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: SQL.Connection.selectOne

Source pointer: /41/method/26

```text
selectOne(string $table, object $fields, object $conditions, object $orderby, bool $indexed): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.Connection.selectSavepoint

Source pointer: /41/method/27

```text
selectSavepoint(string $name): @SQL.SavepointContext
```

```json
{
  "name": "selectSavepoint",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "@SQL.SavepointContext"
    }
  ]
}
```

## method: SQL.Connection.selectTransaction

Source pointer: /41/method/28

```text
selectTransaction([parameter metadata absent]): @SQL.TransactionContext
```

```json
{
  "name": "selectTransaction",
  "return": [
    {
      "type": "@SQL.TransactionContext"
    }
  ]
}
```

## method: SQL.Connection.setCharset

Source pointer: /41/method/29

```text
setCharset(string $charset): this
```

```json
{
  "name": "setCharset",
  "param": [
    {
      "name": "charset",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.Connection.update

Source pointer: /41/method/30

```text
update(string $table, object $data, object $conditions): int
```

```json
{
  "name": "update",
  "param": [
    {
      "name": "table",
      "type": "string"
    },
    {
      "name": "data",
      "type": "object",
      "value": "[field: value, ...]"
    },
    {
      "name": "conditions",
      "type": "object",
      "value": "[field: value, ...]"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.Connection.updateOrInsert

Source pointer: /41/method/31

```text
updateOrInsert(string $table, object $data, object $conditions): int
```

```json
{
  "name": "updateOrInsert",
  "param": [
    {
      "name": "table",
      "type": "string"
    },
    {
      "name": "data",
      "type": "object",
      "value": "[field: value, ...]"
    },
    {
      "name": "conditions",
      "type": "object",
      "value": "[field: value, ...]"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

# Zymba reference: SQL.MySQL

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/42
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.MySQL

Source pointer: /42

```json
{
  "name": "SQL.MySQL",
  "static": false,
  "extend": "SQL.Connection",
  "description": "MySQL connection prototype."
}
```

## method: SQL.MySQL.construct

Source pointer: /42/method/0

```text
construct(string $server, string $dbname, string $username, string $password)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "server",
      "type": "string"
    },
    {
      "name": "dbname",
      "type": "string"
    },
    {
      "name": "username",
      "type": "string"
    },
    {
      "name": "password",
      "type": "string"
    }
  ]
}
```

# Zymba reference: SQL.PostgreSQL

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/43
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.PostgreSQL

Source pointer: /43

```json
{
  "name": "SQL.PostgreSQL",
  "static": false,
  "extend": "SQL.Connection",
  "description": "PostgreSQL connection prototype."
}
```

## method: SQL.PostgreSQL.construct

Source pointer: /43/method/0

```text
construct(string $server, string $dbname, string $username, string $password)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "server",
      "type": "string"
    },
    {
      "name": "dbname",
      "type": "string"
    },
    {
      "name": "username",
      "type": "string"
    },
    {
      "name": "password",
      "type": "string"
    }
  ]
}
```

## method: SQL.PostgreSQL.disableTracing

Source pointer: /43/method/1

```text
disableTracing([parameter metadata absent]): this
```

```json
{
  "name": "disableTracing",
  "annotation": [
    "This function is complementary to \"enableTracing\"."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.PostgreSQL.enableTracing

Source pointer: /43/method/2

```text
enableTracing(string $path): this
```

```json
{
  "name": "enableTracing",
  "annotation": [
    "This function is complementary to \"disableTracing\"."
  ],
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.PostgreSQL.getHost

Source pointer: /43/method/3

```text
getHost([parameter metadata absent]): string
```

```json
{
  "name": "getHost",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.PostgreSQL.getPort

Source pointer: /43/method/4

```text
getPort([parameter metadata absent]): int
```

```json
{
  "name": "getPort",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.PostgreSQL.insertReturning

Source pointer: /43/method/5

```text
insertReturning(string $table, object $data, object $fields, bool $indexed): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.PostgreSQL.isConnected

Source pointer: /43/method/6

```text
isConnected([parameter metadata absent]): bool
```

```json
{
  "name": "isConnected",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

# Zymba reference: SQL.ResultSet

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/44
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.ResultSet

Source pointer: /44

```json
{
  "name": "SQL.ResultSet",
  "static": false,
  "extend": "Base",
  "description": "Abstract SQL result set prototype."
}
```

## method: SQL.ResultSet.close

Source pointer: /44/method/0

```text
close([parameter metadata absent])
```

```json
{
  "name": "close",
  "description": "Closes this result set and frees its associated resources."
}
```

## method: SQL.ResultSet.countFields

Source pointer: /44/method/1

```text
countFields([parameter metadata absent]): int
```

```json
{
  "name": "countFields",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.ResultSet.countRows

Source pointer: /44/method/2

```text
countRows([parameter metadata absent]): int
```

```json
{
  "name": "countRows",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.ResultSet.exit

Source pointer: /44/method/3

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit",
  "description": "Closes this result set and frees its associated resources for the purpose of contextualization."
}
```

## method: SQL.ResultSet.fetch

Source pointer: /44/method/4

```text
fetch(bool $indexed): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.ResultSet.fetchAll

Source pointer: /44/method/5

```text
fetchAll(bool $indexed): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: SQL.ResultSet.fetchAllOfField

Source pointer: /44/method/6

```text
fetchAllOfField(int $index): object
```

```json
{
  "name": "fetchAllOfField",
  "annotation": [
    "This function may advance the position within the result set."
  ],
  "param": [
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[value, ...]"
    }
  ]
}
```

## method: SQL.ResultSet.fetchTail

Source pointer: /44/method/7

```text
fetchTail(bool $indexed): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: SQL.ResultSet.fetchTailOfField

Source pointer: /44/method/8

```text
fetchTailOfField(int $index): object
```

```json
{
  "name": "fetchTailOfField",
  "annotation": [
    "This function may advance the position within the result set."
  ],
  "param": [
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[value, ...]"
    }
  ]
}
```

## method: SQL.ResultSet.getFieldName

Source pointer: /44/method/9

```text
getFieldName(int $index): string
```

```json
{
  "name": "getFieldName",
  "param": [
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.ResultSet.getFieldTable

Source pointer: /44/method/10

```text
getFieldTable(int $index): string
```

```json
{
  "name": "getFieldTable",
  "param": [
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.ResultSet.getFieldType

Source pointer: /44/method/11

```text
getFieldType(int $index): int | string
```

```json
{
  "name": "getFieldType",
  "param": [
    {
      "name": "index",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "int"
    },
    {
      "type": "string"
    }
  ]
}
```

## method: SQL.ResultSet.getPosition

Source pointer: /44/method/12

```text
getPosition([parameter metadata absent]): int
```

```json
{
  "name": "getPosition",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: SQL.ResultSet.hasMore

Source pointer: /44/method/13

```text
hasMore([parameter metadata absent]): bool
```

```json
{
  "name": "hasMore",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: SQL.ResultSet.listFieldNames

Source pointer: /44/method/14

```text
listFieldNames([parameter metadata absent]): object
```

```json
{
  "name": "listFieldNames",
  "return": [
    {
      "type": "object",
      "value": "[field, ...]"
    }
  ]
}
```

## method: SQL.ResultSet.next

Source pointer: /44/method/15

```text
next([parameter metadata absent]): object | null
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.ResultSet.reset

Source pointer: /44/method/16

```text
reset([parameter metadata absent]): this
```

```json
{
  "name": "reset",
  "annotation": [
    "This function may alter the position within the result set."
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.ResultSet.seek

Source pointer: /44/method/17

```text
seek(int $position): this
```

```json
{
  "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"
    }
  ]
}
```

## method: SQL.ResultSet.skip

Source pointer: /44/method/18

```text
skip(int $offset): this
```

```json
{
  "name": "skip",
  "annotation": [
    "This function may alter the position within the result set."
  ],
  "param": [
    {
      "name": "offset",
      "type": "int",
      "default": "1"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: SQL.SQLite3

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/45
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.SQLite3

Source pointer: /45

```json
{
  "name": "SQL.SQLite3",
  "static": false,
  "extend": "SQL.Connection",
  "description": "SQLite3 connection prototype."
}
```

## method: SQL.SQLite3.construct

Source pointer: /45/method/0

```text
construct(string $path, int $mode, string $key)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "mode",
      "type": "int",
      "default": "MODE_READ | MODE_WRITE | MODE_CREATE"
    },
    {
      "name": "key",
      "type": "string"
    }
  ]
}
```

## method: SQL.SQLite3.createAggregate

Source pointer: /45/method/1

```text
createAggregate(string $name, function $callback_step, function $callback_final): this
```

```json
{
  "name": "createAggregate",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "callback_step",
      "type": "function"
    },
    {
      "name": "callback_final",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.SQLite3.createCollation

Source pointer: /45/method/2

```text
createCollation(string $name, function $callback): this
```

```json
{
  "name": "createCollation",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "callback",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: SQL.SQLite3.createFunction

Source pointer: /45/method/3

```text
createFunction(string $name, function $callback): this
```

```json
{
  "name": "createFunction",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "callback",
      "type": "function"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## constant: SQL.SQLite3.MODE_READ

Source pointer: /45/const/0

```json
{
  "name": "MODE_READ",
  "type": "int",
  "description": "SQLite3 read mode"
}
```

## constant: SQL.SQLite3.MODE_WRITE

Source pointer: /45/const/1

```json
{
  "name": "MODE_WRITE",
  "type": "int",
  "description": "SQLite3 write mode, implies read mode"
}
```

## constant: SQL.SQLite3.MODE_CREATE

Source pointer: /45/const/2

```json
{
  "name": "MODE_CREATE",
  "type": "int",
  "description": "SQLite3 create mode, implies write mode"
}
```

# Zymba reference: SQL.SavepointContext

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/46
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.SavepointContext

Source pointer: /46

```json
{
  "name": "SQL.SavepointContext",
  "static": false,
  "extend": "Base",
  "description": "Abstract SQL savepoint context prototype."
}
```

## method: SQL.SavepointContext.enter

Source pointer: /46/method/0

```text
enter([parameter metadata absent])
```

```json
{
  "name": "enter"
}
```

## method: SQL.SavepointContext.exit

Source pointer: /46/method/1

```text
exit(mixed $exception)
```

```json
{
  "name": "exit",
  "param": [
    {
      "name": "exception",
      "type": "mixed"
    }
  ]
}
```

# Zymba reference: SQL.TransactionContext

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/47
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: SQL.TransactionContext

Source pointer: /47

```json
{
  "name": "SQL.TransactionContext",
  "static": false,
  "extend": "Base",
  "description": "Abstract SQL transaction context prototype."
}
```

## method: SQL.TransactionContext.enter

Source pointer: /47/method/0

```text
enter([parameter metadata absent])
```

```json
{
  "name": "enter"
}
```

## method: SQL.TransactionContext.exit

Source pointer: /47/method/1

```text
exit(mixed $exception)
```

```json
{
  "name": "exit",
  "param": [
    {
      "name": "exception",
      "type": "mixed"
    }
  ]
}
```

# Zymba reference: Statistic

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/48
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Statistic

Source pointer: /48

```json
{
  "name": "Statistic",
  "static": true,
  "description": "Static statistical functions."
}
```

## method: Statistic.arithmeticMean

Source pointer: /48/method/0

```text
arithmeticMean(object $values, ?object $weights): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.average

Source pointer: /48/method/1

```text
average(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.averageDeviation

Source pointer: /48/method/2

```text
averageDeviation(object $values, ?number $center): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.centralMoment

Source pointer: /48/method/3

```text
centralMoment(object $values, number $order, ?number $center): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.count

Source pointer: /48/method/4

```text
count(object $values): int
```

```json
{
  "name": "count",
  "description": "Counts the total number of values.",
  "param": [
    {
      "name": "values",
      "type": "object",
      "value": "[value, ...]"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Statistic.exponentialMovingAverage

Source pointer: /48/method/5

```text
exponentialMovingAverage(object $values, ?number $exponent): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.geometricMean

Source pointer: /48/method/6

```text
geometricMean(object $values, ?object $weights): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.harmonicMean

Source pointer: /48/method/7

```text
harmonicMean(object $values, ?object $weights): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.kurtosisPop

Source pointer: /48/method/8

```text
kurtosisPop(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.kurtosisSamp

Source pointer: /48/method/9

```text
kurtosisSamp(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.linearMovingAverage

Source pointer: /48/method/10

```text
linearMovingAverage(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.maximum

Source pointer: /48/method/11

```text
maximum(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.median

Source pointer: /48/method/12

```text
median(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.medianDeviation

Source pointer: /48/method/13

```text
medianDeviation(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.midrange

Source pointer: /48/method/14

```text
midrange(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.minimum

Source pointer: /48/method/15

```text
minimum(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.mode

Source pointer: /48/method/16

```text
mode(object $values): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Statistic.product

Source pointer: /48/method/17

```text
product(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.quadraticMean

Source pointer: /48/method/18

```text
quadraticMean(object $values): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.range

Source pointer: /48/method/19

```text
range(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.rawMoment

Source pointer: /48/method/20

```text
rawMoment(object $values, number $order): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.skewnessPop

Source pointer: /48/method/21

```text
skewnessPop(object $values): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.skewnessSamp

Source pointer: /48/method/22

```text
skewnessSamp(object $values): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.standardDeviationPop

Source pointer: /48/method/23

```text
standardDeviationPop(object $values): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.standardDeviationSamp

Source pointer: /48/method/24

```text
standardDeviationSamp(object $values): float | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.standardScore

Source pointer: /48/method/25

```text
standardScore(object $values): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: Statistic.sum

Source pointer: /48/method/26

```text
sum(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.variancePop

Source pointer: /48/method/27

```text
variancePop(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

## method: Statistic.varianceSamp

Source pointer: /48/method/28

```text
varianceSamp(object $values): number | null
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: String

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/49
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: String

Source pointer: /49

```json
{
  "name": "String",
  "static": true,
  "description": "Static string related functions."
}
```

## method: String.byteAt

Source pointer: /49/method/0

```text
byteAt(string $string, int $offset): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.byteCodeAt

Source pointer: /49/method/1

```text
byteCodeAt(string $string, int $offset): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.byteIndexOf

Source pointer: /49/method/2

```text
byteIndexOf(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.capitalize

Source pointer: /49/method/3

```text
capitalize(string $string): string
```

```json
{
  "name": "capitalize",
  "description": "Capitalizes the first character within a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.capitalizeWords

Source pointer: /49/method/4

```text
capitalizeWords(string $string): string
```

```json
{
  "name": "capitalizeWords",
  "description": "Capitalizes every word within a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.charAt

Source pointer: /49/method/5

```text
charAt(string $string, int $offset): string | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.charCodeAt

Source pointer: /49/method/6

```text
charCodeAt(string $string, int $offset): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.chop

Source pointer: /49/method/7

```text
chop(string $string, int $length, string $delimiter): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.chopOnBytes

Source pointer: /49/method/8

```text
chopOnBytes(string $string, int $length, string $delimiter): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.compare

Source pointer: /49/method/9

```text
compare(string $string1, string $string2): int | int | int
```

```json
{
  "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"
    }
  ]
}
```

## method: String.compareNatural

Source pointer: /49/method/10

```text
compareNatural(string $string1, string $string2): int | int | int
```

```json
{
  "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"
    }
  ]
}
```

## method: String.concat

Source pointer: /49/method/11

```text
concat(variadic $strings): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.contains

Source pointer: /49/method/12

```text
contains(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.containsInsensitive

Source pointer: /49/method/13

```text
containsInsensitive(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.convert

Source pointer: /49/method/14

```text
convert(string $string, string $from, string $to): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.countBytes

Source pointer: /49/method/15

```text
countBytes(string $string): int
```

```json
{
  "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"
    }
  ]
}
```

## method: String.countChars

Source pointer: /49/method/16

```text
countChars(string $string): int
```

```json
{
  "name": "countChars",
  "description": "Counts the total number of characters within a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: String.countDistinctBytes

Source pointer: /49/method/17

```text
countDistinctBytes(string $string): int
```

```json
{
  "name": "countDistinctBytes",
  "description": "Counts the total number of distinct bytes within a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: String.countDistinctChars

Source pointer: /49/method/18

```text
countDistinctChars(string $string): int
```

```json
{
  "name": "countDistinctChars",
  "description": "Counts the total number of distinct characters within a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: String.countSubstring

Source pointer: /49/method/19

```text
countSubstring(string $string, string $substring): int
```

```json
{
  "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"
    }
  ]
}
```

## method: String.countUsedBytes

Source pointer: /49/method/20

```text
countUsedBytes(string $string): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.countUsedChars

Source pointer: /49/method/21

```text
countUsedChars(string $string): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.crc32

Source pointer: /49/method/22

```text
crc32(string $string): int
```

```json
{
  "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"
    }
  ]
}
```

## method: String.distanceBetween

Source pointer: /49/method/23

```text
distanceBetween(string $string1, string $string2): int
```

```json
{
  "name": "distanceBetween",
  "description": "Measures the Levenshtein distance between two strings.",
  "param": [
    {
      "name": "string1",
      "type": "string"
    },
    {
      "name": "string2",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: String.endsWith

Source pointer: /49/method/24

```text
endsWith(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.endsWithInsensitive

Source pointer: /49/method/25

```text
endsWithInsensitive(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.equals

Source pointer: /49/method/26

```text
equals(string $string1, string $string2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.equalsInsensitive

Source pointer: /49/method/27

```text
equalsInsensitive(string $string1, string $string2): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.escapeC

Source pointer: /49/method/28

```text
escapeC(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.foldCase

Source pointer: /49/method/29

```text
foldCase(string $string): string
```

```json
{
  "name": "foldCase",
  "description": "Converts a string according to length-preserving case-folding rules (UTF-8).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.format

Source pointer: /49/method/30

```text
format(string $string, variadic $arguments): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.fromByteCodes

Source pointer: /49/method/31

```text
fromByteCodes(object $codes): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.fromCharCodes

Source pointer: /49/method/32

```text
fromCharCodes(object $codes): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.fromHex

Source pointer: /49/method/33

```text
fromHex(string $string): string
```

```json
{
  "name": "fromHex",
  "annotation": [
    "This function is complementary to \"toHex\"."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.fromLatin1

Source pointer: /49/method/34

```text
fromLatin1(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.hasByteIndex

Source pointer: /49/method/35

```text
hasByteIndex(string $string, int $index): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.hasIndex

Source pointer: /49/method/36

```text
hasIndex(string $string, int $index): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.head

Source pointer: /49/method/37

```text
head(string $string): string
```

```json
{
  "name": "head",
  "description": "Returns the character-based head of a string, meaning only the first character.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.headOnBytes

Source pointer: /49/method/38

```text
headOnBytes(string $string): string
```

```json
{
  "name": "headOnBytes",
  "description": "Returns the byte-based head of a string, meaning only the first byte.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.indexOf

Source pointer: /49/method/39

```text
indexOf(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.indexOfInsensitive

Source pointer: /49/method/40

```text
indexOfInsensitive(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.insert

Source pointer: /49/method/41

```text
insert(string $string, string $substring, int $offset): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.insertOnBytes

Source pointer: /49/method/42

```text
insertOnBytes(string $string, string $substring, int $offset): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.isBinaryDigits

Source pointer: /49/method/43

```text
isBinaryDigits(string $string): bool
```

```json
{
  "name": "isBinaryDigits",
  "description": "Determines whether a string consists only of characters representing binary digits.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isDecimalDigits

Source pointer: /49/method/44

```text
isDecimalDigits(string $string): bool
```

```json
{
  "name": "isDecimalDigits",
  "description": "Determines whether a string consists only of characters representing decimal digits.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isEmpty

Source pointer: /49/method/45

```text
isEmpty(string $string): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.isHexDigits

Source pointer: /49/method/46

```text
isHexDigits(string $string): bool
```

```json
{
  "name": "isHexDigits",
  "description": "Determines whether a string consists only of characters representing hexadecimal digits.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isMarkedUTF8

Source pointer: /49/method/47

```text
isMarkedUTF8(string $string): bool
```

```json
{
  "name": "isMarkedUTF8",
  "description": "Determines whether a string has an UTF-8 byte order mark (BOM).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isOctalDigits

Source pointer: /49/method/48

```text
isOctalDigits(string $string): bool
```

```json
{
  "name": "isOctalDigits",
  "description": "Determines whether a string consists only of characters representing octal digits.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isPrintable

Source pointer: /49/method/49

```text
isPrintable(string $string): bool
```

```json
{
  "name": "isPrintable",
  "description": "Determines whether a string represents a valid sequence of printable US-ASCII characters.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isSingleByte

Source pointer: /49/method/50

```text
isSingleByte(string $string): bool
```

```json
{
  "name": "isSingleByte",
  "description": "Determines whether a string consists only of a single byte.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isSingleChar

Source pointer: /49/method/51

```text
isSingleChar(string $string): bool
```

```json
{
  "name": "isSingleChar",
  "description": "Determines whether a string consists only of a single character.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isValidASCII

Source pointer: /49/method/52

```text
isValidASCII(string $string): bool
```

```json
{
  "name": "isValidASCII",
  "description": "Determines whether a string represents a valid sequence of US-ASCII characters.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isValidUTF8

Source pointer: /49/method/53

```text
isValidUTF8(string $string): bool
```

```json
{
  "name": "isValidUTF8",
  "description": "Determines whether a string represents a valid sequence of UTF-8 characters.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.isWhiteSpace

Source pointer: /49/method/54

```text
isWhiteSpace(string $string): bool
```

```json
{
  "name": "isWhiteSpace",
  "description": "Determines whether a string consists only of US-ASCII white space characters.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: String.lastByteIndexOf

Source pointer: /49/method/55

```text
lastByteIndexOf(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.lastIndexOf

Source pointer: /49/method/56

```text
lastIndexOf(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.lastIndexOfInsensitive

Source pointer: /49/method/57

```text
lastIndexOfInsensitive(string $string, string $substring): int | null
```

```json
{
  "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"
    }
  ]
}
```

## method: String.metaphone

Source pointer: /49/method/58

```text
metaphone(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.normalizeLineBreaks

Source pointer: /49/method/59

```text
normalizeLineBreaks(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.normalizeWhiteSpace

Source pointer: /49/method/60

```text
normalizeWhiteSpace(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.pad

Source pointer: /49/method/61

```text
pad(string $string, int $length, string $padding): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.padOnBytes

Source pointer: /49/method/62

```text
padOnBytes(string $string, int $length, string $padding): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.partition

Source pointer: /49/method/63

```text
partition(string $string, int $length): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.partitionOnBytes

Source pointer: /49/method/64

```text
partitionOnBytes(string $string, int $length): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.quote

Source pointer: /49/method/65

```text
quote(string $string, string $delimiter): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.repeat

Source pointer: /49/method/66

```text
repeat(string $string, int $count): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.replace

Source pointer: /49/method/67

```text
replace(string $string, string $substring, string $replacement, int $limit): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.replaceMultiple

Source pointer: /49/method/68

```text
replaceMultiple(string $string, object $replacements): string
```

```json
{
  "name": "replaceMultiple",
  "param": [
    {
      "name": "string",
      "type": "string"
    },
    {
      "name": "replacements",
      "type": "object",
      "value": "[substring: replacement, ...]"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.reverse

Source pointer: /49/method/69

```text
reverse(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.reverseOnBytes

Source pointer: /49/method/70

```text
reverseOnBytes(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.scrub

Source pointer: /49/method/71

```text
scrub(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.slice

Source pointer: /49/method/72

```text
slice(string $string, int $offset, ?int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.sliceOnBytes

Source pointer: /49/method/73

```text
sliceOnBytes(string $string, int $offset, ?int $length): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.soundex

Source pointer: /49/method/74

```text
soundex(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.splice

Source pointer: /49/method/75

```text
splice(string $string, int $offset, ?int $length, string $replacement): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.spliceOnBytes

Source pointer: /49/method/76

```text
spliceOnBytes(string $string, int $offset, ?int $length, string $replacement): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.split

Source pointer: /49/method/77

```text
split(string $string, string $delimiter, int $limit): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.splitNonEmpty

Source pointer: /49/method/78

```text
splitNonEmpty(string $string, string $delimiter, int $limit): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.startsWith

Source pointer: /49/method/79

```text
startsWith(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.startsWithInsensitive

Source pointer: /49/method/80

```text
startsWithInsensitive(string $string, string $substring): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: String.tail

Source pointer: /49/method/81

```text
tail(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.tailOnBytes

Source pointer: /49/method/82

```text
tailOnBytes(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.toByteCodes

Source pointer: /49/method/83

```text
toByteCodes(string $string): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.toCharCodes

Source pointer: /49/method/84

```text
toCharCodes(string $string): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

## method: String.toHex

Source pointer: /49/method/85

```text
toHex(string $string): string
```

```json
{
  "name": "toHex",
  "annotation": [
    "This function is complementary to \"fromHex\"."
  ],
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.toLatin1

Source pointer: /49/method/86

```text
toLatin1(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.toLower

Source pointer: /49/method/87

```text
toLower(string $string): string
```

```json
{
  "name": "toLower",
  "description": "Converts a string to lower case (UTF-8).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.toLowerASCII

Source pointer: /49/method/88

```text
toLowerASCII(string $string): string
```

```json
{
  "name": "toLowerASCII",
  "description": "Converts a string to lower case (US-ASCII only).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.toUpper

Source pointer: /49/method/89

```text
toUpper(string $string): string
```

```json
{
  "name": "toUpper",
  "description": "Converts a string to upper case (UTF-8).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.toUpperASCII

Source pointer: /49/method/90

```text
toUpperASCII(string $string): string
```

```json
{
  "name": "toUpperASCII",
  "description": "Converts a string to upper case (US-ASCII only).",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: String.trim

Source pointer: /49/method/91

```text
trim(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.trimLeft

Source pointer: /49/method/92

```text
trimLeft(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.trimRight

Source pointer: /49/method/93

```text
trimRight(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.truncate

Source pointer: /49/method/94

```text
truncate(string $string, int $offset, int $length, string $marker): string
```

```json
{
  "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"
    }
  ]
}
```

## method: String.unescapeC

Source pointer: /49/method/95

```text
unescapeC(string $string): string
```

```json
{
  "name": "unescapeC",
  "description": "Resolve all C-style escape sequences in a string.",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: System

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/50
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: System

Source pointer: /50

```json
{
  "name": "System",
  "static": true,
  "description": "Static system related constants and functions."
}
```

## method: System.getCurrentMemoryUsage

Source pointer: /50/method/0

```text
getCurrentMemoryUsage([parameter metadata absent]): int
```

```json
{
  "name": "getCurrentMemoryUsage",
  "description": "Gets the current memory usage of the underlying runtime environment in number of bytes.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: System.getHost

Source pointer: /50/method/1

```text
getHost([parameter metadata absent]): string
```

```json
{
  "name": "getHost",
  "description": "Gets the host name of the system.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: System.getMachine

Source pointer: /50/method/2

```text
getMachine([parameter metadata absent]): string
```

```json
{
  "name": "getMachine",
  "description": "Gets the machine architecture of the system.",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: System.getMonotonicTime

Source pointer: /50/method/3

```text
getMonotonicTime([parameter metadata absent]): int | float
```

```json
{
  "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"
    }
  ]
}
```

## method: System.getPeakMemoryUsage

Source pointer: /50/method/4

```text
getPeakMemoryUsage([parameter metadata absent]): int
```

```json
{
  "name": "getPeakMemoryUsage",
  "description": "Gets the peak memory usage of the underlying runtime environment in number of bytes.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: System.getProcessID

Source pointer: /50/method/5

```text
getProcessID([parameter metadata absent]): int
```

```json
{
  "name": "getProcessID",
  "description": "Gets the process ID of the underlying runtime environment.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: System.listCommandLineArguments

Source pointer: /50/method/6

```text
listCommandLineArguments([parameter metadata absent]): object
```

```json
{
  "name": "listCommandLineArguments",
  "description": "Lists all command line arguments passed to the underlying runtime environment.",
  "return": [
    {
      "type": "object",
      "value": "[argument, ...]"
    }
  ]
}
```

## method: System.sleep

Source pointer: /50/method/7

```text
sleep(number $duration)
```

```json
{
  "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"
    }
  ]
}
```

## constant: System.OS

Source pointer: /50/const/0

```json
{
  "name": "OS",
  "type": "string",
  "description": "Operating system identifier"
}
```

## constant: System.PHPVERSION

Source pointer: /50/const/1

```json
{
  "name": "PHPVERSION",
  "type": "string",
  "description": "PHP version number"
}
```

## constant: System.SAPI

Source pointer: /50/const/2

```json
{
  "name": "SAPI",
  "type": "string",
  "description": "Server API identifier"
}
```

# Zymba reference: URI

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/51
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: URI

Source pointer: /51

```json
{
  "name": "URI",
  "static": true,
  "description": "Static URI related functions."
}
```

## method: URI.createDataURI

Source pointer: /51/method/0

```text
createDataURI(string $string, string $type, string $charset): string
```

```json
{
  "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"
    }
  ]
}
```

## method: URI.createQuery

Source pointer: /51/method/1

```text
createQuery(object $attributes): string
```

```json
{
  "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"
    }
  ]
}
```

## method: URI.decode

Source pointer: /51/method/2

```text
decode(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: URI.encode

Source pointer: /51/method/3

```text
encode(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: URI.getAuthority

Source pointer: /51/method/4

```text
getAuthority(string $uri): string
```

```json
{
  "name": "getAuthority",
  "description": "Gets the authority component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getFragment

Source pointer: /51/method/5

```text
getFragment(string $uri): string
```

```json
{
  "name": "getFragment",
  "description": "Gets the fragment component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getHierarchy

Source pointer: /51/method/6

```text
getHierarchy(string $uri): string
```

```json
{
  "name": "getHierarchy",
  "description": "Gets the hierarchy component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getHost

Source pointer: /51/method/7

```text
getHost(string $uri): string
```

```json
{
  "name": "getHost",
  "description": "Gets the host name component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getPassword

Source pointer: /51/method/8

```text
getPassword(string $uri): string
```

```json
{
  "name": "getPassword",
  "description": "Gets the password component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getPath

Source pointer: /51/method/9

```text
getPath(string $uri): string
```

```json
{
  "name": "getPath",
  "description": "Gets the path name component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getPort

Source pointer: /51/method/10

```text
getPort(string $uri): string
```

```json
{
  "name": "getPort",
  "description": "Gets the port number component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getQuery

Source pointer: /51/method/11

```text
getQuery(string $uri): string
```

```json
{
  "name": "getQuery",
  "description": "Gets the query component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getScheme

Source pointer: /51/method/12

```text
getScheme(string $uri): string
```

```json
{
  "name": "getScheme",
  "description": "Gets the scheme component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.getUser

Source pointer: /51/method/13

```text
getUser(string $uri): string
```

```json
{
  "name": "getUser",
  "description": "Gets the username component of an URI.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: URI.isAbsolute

Source pointer: /51/method/14

```text
isAbsolute(string $uri): bool
```

```json
{
  "name": "isAbsolute",
  "description": "Determines whether an URI is absolute, meaning it has a scheme component.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: URI.isFile

Source pointer: /51/method/15

```text
isFile(string $path): bool
```

```json
{
  "name": "isFile",
  "description": "Determines whether an URI is of the file URI scheme.",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: URI.isValid

Source pointer: /51/method/16

```text
isValid(string $uri): bool
```

```json
{
  "name": "isValid",
  "description": "Determines whether an URI is valid.",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: URI.normalize

Source pointer: /51/method/17

```text
normalize(string $uri): string
```

```json
{
  "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"
    }
  ]
}
```

## method: URI.parse

Source pointer: /51/method/18

```text
parse(string $uri): object
```

```json
{
  "name": "parse",
  "param": [
    {
      "name": "uri",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[\"scheme\": ..., \"user\": ..., \"password\": ..., \"host\": ..., \"port\": ..., \"path\": ..., \"query\": ..., \"fragment\": ...]"
    }
  ]
}
```

## method: URI.parseQuery

Source pointer: /51/method/19

```text
parseQuery(string $query): object
```

```json
{
  "name": "parseQuery",
  "param": [
    {
      "name": "query",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

# Zymba reference: Var

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/52
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: Var

Source pointer: /52

```json
{
  "name": "Var",
  "static": true,
  "description": "Static variable related functions."
}
```

## method: Var.clone

Source pointer: /52/method/0

```text
clone(mixed $value): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.cloneDeep

Source pointer: /52/method/1

```text
cloneDeep(mixed $value): mixed
```

```json
{
  "name": "cloneDeep",
  "description": "Clones the value by creating a deep copy.",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: Var.compare

Source pointer: /52/method/2

```text
compare(mixed $value1, mixed $value2): int | int | int
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.count

Source pointer: /52/method/3

```text
count(mixed $value): int
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.countGlobalVariables

Source pointer: /52/method/4

```text
countGlobalVariables([parameter metadata absent]): int
```

```json
{
  "name": "countGlobalVariables",
  "description": "Counts the total number of global variables.",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: Var.exists

Source pointer: /52/method/5

```text
exists(mixed $value): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.fromJSON

Source pointer: /52/method/6

```text
fromJSON(string $string): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.fromSerializedPHP

Source pointer: /52/method/7

```text
fromSerializedPHP(string $string): mixed
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.isBool

Source pointer: /52/method/8

```text
isBool(mixed $value): bool
```

```json
{
  "name": "isBool",
  "description": "Determines whether a value is of type \"bool\", meaning either true or false.",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isComplex

Source pointer: /52/method/9

```text
isComplex(mixed $value): bool
```

```json
{
  "name": "isComplex",
  "description": "Determines whether a value is of a complex type.",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isEmpty

Source pointer: /52/method/10

```text
isEmpty(mixed $value): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.isFloat

Source pointer: /52/method/11

```text
isFloat(mixed $value): bool
```

```json
{
  "name": "isFloat",
  "description": "Determines whether a value is of type \"float\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isFunction

Source pointer: /52/method/12

```text
isFunction(mixed $value): bool
```

```json
{
  "name": "isFunction",
  "description": "Determines whether a value is of type \"function\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isInt

Source pointer: /52/method/13

```text
isInt(mixed $value): bool
```

```json
{
  "name": "isInt",
  "description": "Determines whether a value is of type \"int\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isNull

Source pointer: /52/method/14

```text
isNull(mixed $value): bool
```

```json
{
  "name": "isNull",
  "description": "Determines whether a value is null.",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isNumber

Source pointer: /52/method/15

```text
isNumber(mixed $value): bool
```

```json
{
  "name": "isNumber",
  "description": "Determines whether a value is a number, meaning of type \"int\" or \"float\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isNumeric

Source pointer: /52/method/16

```text
isNumeric(mixed $value): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.isObject

Source pointer: /52/method/17

```text
isObject(mixed $value): bool
```

```json
{
  "name": "isObject",
  "description": "Determines whether a value is of type \"object\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isScalar

Source pointer: /52/method/18

```text
isScalar(mixed $value): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.isString

Source pointer: /52/method/19

```text
isString(mixed $value): bool
```

```json
{
  "name": "isString",
  "description": "Determines whether a value is of type \"string\".",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: Var.isValidJSON

Source pointer: /52/method/20

```text
isValidJSON(string $string): bool
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.listGlobalVariableNames

Source pointer: /52/method/21

```text
listGlobalVariableNames([parameter metadata absent]): object
```

```json
{
  "name": "listGlobalVariableNames",
  "description": "Lists all variable names of global scope.",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: Var.listGlobalVariables

Source pointer: /52/method/22

```text
listGlobalVariables([parameter metadata absent]): object
```

```json
{
  "name": "listGlobalVariables",
  "description": "Lists all variables of global scope.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: Var.pack

Source pointer: /52/method/23

```text
pack(string $format, variadic $arguments): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.toJSON

Source pointer: /52/method/24

```text
toJSON(mixed $value): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.toPrettyJSON

Source pointer: /52/method/25

```text
toPrettyJSON(mixed $value): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.toSerializedPHP

Source pointer: /52/method/26

```text
toSerializedPHP(mixed $value): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.toSource

Source pointer: /52/method/27

```text
toSource(mixed $value): string
```

```json
{
  "name": "toSource",
  "description": "Returns the Zymba source-code literal representation of a value.",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: Var.typeOf

Source pointer: /52/method/28

```text
typeOf(mixed $value): string
```

```json
{
  "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"
    }
  ]
}
```

## method: Var.unpack

Source pointer: /52/method/29

```text
unpack(string $format, string $string): object
```

```json
{
  "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, ...]"
    }
  ]
}
```

# Zymba reference: XML

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/53
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: XML

Source pointer: /53

```json
{
  "name": "XML",
  "static": true,
  "description": "Static XML related functions."
}
```

## method: XML.createFromTree

Source pointer: /53/method/0

```text
createFromTree(object $tree): string
```

```json
{
  "name": "createFromTree",
  "param": [
    {
      "name": "tree",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: XML.escape

Source pointer: /53/method/1

```text
escape(string $string): string
```

```json
{
  "name": "escape",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: XML.parse

Source pointer: /53/method/2

```text
parse(string $document, ?function $callback_open, ?function $callback_close, ?function $callback_cdata, ?object $bind, bool $preservecase)
```

```json
{
  "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"
    }
  ]
}
```

## method: XML.parseToTree

Source pointer: /53/method/3

```text
parseToTree(string $document, bool $preservecase): object
```

```json
{
  "name": "parseToTree",
  "param": [
    {
      "name": "document",
      "type": "string"
    },
    {
      "name": "preservecase",
      "type": "bool",
      "default": "false"
    }
  ],
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: XML.unescape

Source pointer: /53/method/4

```text
unescape(string $string): string
```

```json
{
  "name": "unescape",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: ZIP

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/54
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZIP

Source pointer: /54

```json
{
  "name": "ZIP",
  "static": true,
  "description": "Static ZIP related prototypes."
}
```

# Zymba reference: ZIP.Archive

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/55
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZIP.Archive

Source pointer: /55

```json
{
  "name": "ZIP.Archive",
  "static": false,
  "extend": "Base",
  "description": "ZIP archive prototype."
}
```

## method: ZIP.Archive.construct

Source pointer: /55/method/0

```text
construct(string $path, int $mode)
```

```json
{
  "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"
    }
  ]
}
```

## method: ZIP.Archive.addDirectory

Source pointer: /55/method/1

```text
addDirectory(string $path, string $prefix): this
```

```json
{
  "name": "addDirectory",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "prefix",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.addFile

Source pointer: /55/method/2

```text
addFile(string $path, string $name): this
```

```json
{
  "name": "addFile",
  "param": [
    {
      "name": "path",
      "type": "string"
    },
    {
      "name": "name",
      "type": "string",
      "default": "derived from path"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.close

Source pointer: /55/method/3

```text
close([parameter metadata absent])
```

```json
{
  "name": "close",
  "description": "Closes this archive and frees its associated resources."
}
```

## method: ZIP.Archive.countEntries

Source pointer: /55/method/4

```text
countEntries([parameter metadata absent]): int
```

```json
{
  "name": "countEntries",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZIP.Archive.crc32

Source pointer: /55/method/5

```text
crc32(string $name): int
```

```json
{
  "name": "crc32",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZIP.Archive.createDirectory

Source pointer: /55/method/6

```text
createDirectory(string $name): this
```

```json
{
  "name": "createDirectory",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.delete

Source pointer: /55/method/7

```text
delete(string $name): this
```

```json
{
  "name": "delete",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.exists

Source pointer: /55/method/8

```text
exists(string $name): bool
```

```json
{
  "name": "exists",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZIP.Archive.exit

Source pointer: /55/method/9

```text
exit(mixed $exception)
```

```json
{
  "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"
    }
  ]
}
```

## method: ZIP.Archive.extract

Source pointer: /55/method/10

```text
extract(object $entries, string $path): this
```

```json
{
  "name": "extract",
  "param": [
    {
      "name": "entries",
      "type": "object",
      "value": "[name, ...]"
    },
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.extractAll

Source pointer: /55/method/11

```text
extractAll(string $path): this
```

```json
{
  "name": "extractAll",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.getComment

Source pointer: /55/method/12

```text
getComment(string $name): string
```

```json
{
  "name": "getComment",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZIP.Archive.getCompression

Source pointer: /55/method/13

```text
getCompression(string $name): int
```

```json
{
  "name": "getCompression",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZIP.Archive.getLastModified

Source pointer: /55/method/14

```text
getLastModified(string $name): int
```

```json
{
  "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"
    }
  ]
}
```

## method: ZIP.Archive.getSize

Source pointer: /55/method/15

```text
getSize(string $name): int
```

```json
{
  "name": "getSize",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZIP.Archive.getSizeRaw

Source pointer: /55/method/16

```text
getSizeRaw(string $name): int
```

```json
{
  "name": "getSizeRaw",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZIP.Archive.listEntries

Source pointer: /55/method/17

```text
listEntries([parameter metadata absent]): object
```

```json
{
  "name": "listEntries",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: ZIP.Archive.move

Source pointer: /55/method/18

```text
move(string $name, string $target): this
```

```json
{
  "name": "move",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "target",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.read

Source pointer: /55/method/19

```text
read(string $name, ?int $length): string
```

```json
{
  "name": "read",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "length",
      "type": "?int",
      "default": "maximum length"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZIP.Archive.readRaw

Source pointer: /55/method/20

```text
readRaw(string $name): string
```

```json
{
  "name": "readRaw",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZIP.Archive.restore

Source pointer: /55/method/21

```text
restore(string $name): this
```

```json
{
  "name": "restore",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.rollback

Source pointer: /55/method/22

```text
rollback([parameter metadata absent]): this
```

```json
{
  "name": "rollback",
  "description": "Rolls back this archive by discarding all changes.",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.selectStream

Source pointer: /55/method/23

```text
selectStream(string $name): @IO.Stream
```

```json
{
  "name": "selectStream",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "@IO.Stream"
    }
  ]
}
```

## method: ZIP.Archive.setComment

Source pointer: /55/method/24

```text
setComment(string $name, string $comment): this
```

```json
{
  "name": "setComment",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "comment",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.setCompression

Source pointer: /55/method/25

```text
setCompression(string $name, int $method, int $flags): this
```

```json
{
  "name": "setCompression",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "method",
      "type": "int",
      "default": "COMPRESS_DEFAULT"
    },
    {
      "name": "flags",
      "type": "int"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.setEncryption

Source pointer: /55/method/26

```text
setEncryption(string $name, int $method, ?string $password): this
```

```json
{
  "name": "setEncryption",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "method",
      "type": "int",
      "default": "ENCRYPT_NONE"
    },
    {
      "name": "password",
      "type": "?string",
      "default": "archive password"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.setLastModified

Source pointer: /55/method/27

```text
setLastModified(string $name, ?int $timestamp): this
```

```json
{
  "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"
    }
  ]
}
```

## method: ZIP.Archive.setPassword

Source pointer: /55/method/28

```text
setPassword(string $password): this
```

```json
{
  "name": "setPassword",
  "param": [
    {
      "name": "password",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZIP.Archive.write

Source pointer: /55/method/29

```text
write(string $name, string $string): this
```

```json
{
  "name": "write",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## constant: ZIP.Archive.COMPRESS_DEFAULT

Source pointer: /55/const/0

```json
{
  "name": "COMPRESS_DEFAULT",
  "type": "int",
  "description": "Default compression method (Deflate or Store)"
}
```

## constant: ZIP.Archive.COMPRESS_STORE

Source pointer: /55/const/1

```json
{
  "name": "COMPRESS_STORE",
  "type": "int",
  "description": "Raw store method, no compression"
}
```

## constant: ZIP.Archive.COMPRESS_SHRINK

Source pointer: /55/const/2

```json
{
  "name": "COMPRESS_SHRINK",
  "type": "int",
  "description": "Shrink (LZW) compression method"
}
```

## constant: ZIP.Archive.COMPRESS_REDUCE1

Source pointer: /55/const/3

```json
{
  "name": "COMPRESS_REDUCE1",
  "type": "int",
  "description": "Reduce level 1 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_REDUCE2

Source pointer: /55/const/4

```json
{
  "name": "COMPRESS_REDUCE2",
  "type": "int",
  "description": "Reduce level 2 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_REDUCE3

Source pointer: /55/const/5

```json
{
  "name": "COMPRESS_REDUCE3",
  "type": "int",
  "description": "Reduce level 3 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_REDUCE4

Source pointer: /55/const/6

```json
{
  "name": "COMPRESS_REDUCE4",
  "type": "int",
  "description": "Reduce level 4 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_IMPLODE

Source pointer: /55/const/7

```json
{
  "name": "COMPRESS_IMPLODE",
  "type": "int",
  "description": "Implode compression method"
}
```

## constant: ZIP.Archive.COMPRESS_DEFLATE

Source pointer: /55/const/8

```json
{
  "name": "COMPRESS_DEFLATE",
  "type": "int",
  "description": "Deflate compression method"
}
```

## constant: ZIP.Archive.COMPRESS_DEFLATE64

Source pointer: /55/const/9

```json
{
  "name": "COMPRESS_DEFLATE64",
  "type": "int",
  "description": "Enhanced Deflate (Deflate64) compression method"
}
```

## constant: ZIP.Archive.COMPRESS_PKWARE

Source pointer: /55/const/10

```json
{
  "name": "COMPRESS_PKWARE",
  "type": "int",
  "description": "PKWARE Implode compression method"
}
```

## constant: ZIP.Archive.COMPRESS_BZIP2

Source pointer: /55/const/11

```json
{
  "name": "COMPRESS_BZIP2",
  "type": "int",
  "description": "BZip2 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_LZMA

Source pointer: /55/const/12

```json
{
  "name": "COMPRESS_LZMA",
  "type": "int",
  "description": "LZMA compression method"
}
```

## constant: ZIP.Archive.COMPRESS_TERSE

Source pointer: /55/const/13

```json
{
  "name": "COMPRESS_TERSE",
  "type": "int",
  "description": "TERSE compression method"
}
```

## constant: ZIP.Archive.COMPRESS_LZ77

Source pointer: /55/const/14

```json
{
  "name": "COMPRESS_LZ77",
  "type": "int",
  "description": "LZ77 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_LZMA

Source pointer: /55/const/15

```json
{
  "name": "COMPRESS_LZMA",
  "type": "int",
  "description": "LZMA2 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_ZSTD

Source pointer: /55/const/16

```json
{
  "name": "COMPRESS_ZSTD",
  "type": "int",
  "description": "Zstandard compression method"
}
```

## constant: ZIP.Archive.COMPRESS_MP3

Source pointer: /55/const/17

```json
{
  "name": "COMPRESS_MP3",
  "type": "int",
  "description": "MP3 compression method"
}
```

## constant: ZIP.Archive.COMPRESS_XZ

Source pointer: /55/const/18

```json
{
  "name": "COMPRESS_XZ",
  "type": "int",
  "description": "XZ compression method"
}
```

## constant: ZIP.Archive.COMPRESS_JPEG

Source pointer: /55/const/19

```json
{
  "name": "COMPRESS_JPEG",
  "type": "int",
  "description": "JPEG compression method"
}
```

## constant: ZIP.Archive.COMPRESS_WAVPACK

Source pointer: /55/const/20

```json
{
  "name": "COMPRESS_WAVPACK",
  "type": "int",
  "description": "WavPack compression method"
}
```

## constant: ZIP.Archive.COMPRESS_PPMD

Source pointer: /55/const/21

```json
{
  "name": "COMPRESS_PPMD",
  "type": "int",
  "description": "PPMd compression method"
}
```

## constant: ZIP.Archive.ENCRYPT_NONE

Source pointer: /55/const/22

```json
{
  "name": "ENCRYPT_NONE",
  "type": "int",
  "description": "No encryption"
}
```

## constant: ZIP.Archive.ENCRYPT_PKWARE

Source pointer: /55/const/23

```json
{
  "name": "ENCRYPT_PKWARE",
  "type": "int",
  "description": "Traditional PKWARE encryption method"
}
```

## constant: ZIP.Archive.ENCRYPT_AES128

Source pointer: /55/const/24

```json
{
  "name": "ENCRYPT_AES128",
  "type": "int",
  "description": "AES-128 encryption method"
}
```

## constant: ZIP.Archive.ENCRYPT_AES128

Source pointer: /55/const/25

```json
{
  "name": "ENCRYPT_AES128",
  "type": "int",
  "description": "AES-192 encryption method"
}
```

## constant: ZIP.Archive.ENCRYPT_AES128

Source pointer: /55/const/26

```json
{
  "name": "ENCRYPT_AES128",
  "type": "int",
  "description": "AES-256 encryption method"
}
```

## constant: ZIP.Archive.ENCRYPT_UNKNOWN

Source pointer: /55/const/27

```json
{
  "name": "ENCRYPT_UNKNOWN",
  "type": "int",
  "description": "Unknown encryption method"
}
```

## constant: ZIP.Archive.MODE_READ

Source pointer: /55/const/28

```json
{
  "name": "MODE_READ",
  "type": "int",
  "description": "Archive read mode"
}
```

## constant: ZIP.Archive.MODE_WRITE

Source pointer: /55/const/29

```json
{
  "name": "MODE_WRITE",
  "type": "int",
  "description": "Archive write mode, implies read mode"
}
```

## constant: ZIP.Archive.MODE_CREATE

Source pointer: /55/const/30

```json
{
  "name": "MODE_CREATE",
  "type": "int",
  "description": "Archive create mode, implies write mode"
}
```

## constant: ZIP.Archive.MODE_TRUNCATE

Source pointer: /55/const/31

```json
{
  "name": "MODE_TRUNCATE",
  "type": "int",
  "description": "Archive truncate mode, implies write mode"
}
```

## constant: ZIP.Archive.MODE_OVERWRITE

Source pointer: /55/const/32

```json
{
  "name": "MODE_OVERWRITE",
  "type": "int",
  "description": "Archive overwrite mode, same as create plus truncate mode"
}
```

# Zymba reference: ZLIB

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/56
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZLIB

Source pointer: /56

```json
{
  "name": "ZLIB",
  "static": true,
  "description": "Static ZLIB related functions."
}
```

## method: ZLIB.deflate

Source pointer: /56/method/0

```text
deflate(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: ZLIB.deflateRaw

Source pointer: /56/method/1

```text
deflateRaw(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: ZLIB.gunzip

Source pointer: /56/method/2

```text
gunzip(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: ZLIB.gzip

Source pointer: /56/method/3

```text
gzip(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: ZLIB.inflate

Source pointer: /56/method/4

```text
inflate(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

## method: ZLIB.inflateRaw

Source pointer: /56/method/5

```text
inflateRaw(string $string): string
```

```json
{
  "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"
    }
  ]
}
```

# Zymba reference: ZeyOS

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/57
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS

Source pointer: /57

```json
{
  "name": "ZeyOS",
  "static": true
}
```

## method: ZeyOS.authenticateUser

Source pointer: /57/method/0

```text
authenticateUser(string $name, string $password, string $otp): @ZeyOS.ObjectUser | null
```

```json
{
  "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"
    }
  ]
}
```

## method: ZeyOS.createShareToken

Source pointer: /57/method/1

```text
createShareToken(string $entity, int $id, ?int $expdate): string
```

```json
{
  "name": "createShareToken",
  "param": [
    {
      "name": "entity",
      "type": "string"
    },
    {
      "name": "id",
      "type": "int"
    },
    {
      "name": "expdate",
      "type": "?int",
      "default": "100 days from now"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.createZUGFERD

Source pointer: /57/method/2

```text
createZUGFERD(string $pdf, string $xml): string
```

```json
{
  "name": "createZUGFERD",
  "param": [
    {
      "name": "pdf",
      "type": "string"
    },
    {
      "name": "xml",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.extractZUGFERD

Source pointer: /57/method/3

```text
extractZUGFERD(string $pdf): string | null
```

```json
{
  "name": "extractZUGFERD",
  "param": [
    {
      "name": "pdf",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    },
    {
      "type": "null",
      "description": "if there is no embedded XML"
    }
  ]
}
```

## method: ZeyOS.getTempPath

Source pointer: /57/method/4

```text
getTempPath([parameter metadata absent]): string
```

```json
{
  "name": "getTempPath",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.initializeItems

Source pointer: /57/method/5

```text
initializeItems(object $items): object
```

```json
{
  "name": "initializeItems",
  "param": [
    {
      "name": "items",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.listSessionVariables

Source pointer: /57/method/6

```text
listSessionVariables([parameter metadata absent]): object
```

```json
{
  "name": "listSessionVariables",
  "description": "Lists all session variables.",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: ZeyOS.log

Source pointer: /57/method/7

```text
log(string $message, string $type, string $severity)
```

```json
{
  "name": "log",
  "param": [
    {
      "name": "message",
      "type": "string"
    },
    {
      "name": "type",
      "type": "string"
    },
    {
      "name": "severity",
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.queueMail

Source pointer: /57/method/8

```text
queueMail(string $message, ?int $mailserver, ?int $senddate): ?int
```

```json
{
  "name": "queueMail",
  "param": [
    {
      "name": "message",
      "type": "string"
    },
    {
      "name": "mailserver",
      "type": "?int"
    },
    {
      "name": "senddate",
      "type": "?int"
    }
  ],
  "return": [
    {
      "type": "?int"
    }
  ]
}
```

## method: ZeyOS.readConfig

Source pointer: /57/method/9

```text
readConfig([parameter metadata absent]): object
```

```json
{
  "name": "readConfig",
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.resetCron

Source pointer: /57/method/10

```text
resetCron(string $name)
```

```json
{
  "name": "resetCron",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.selectDatabase

Source pointer: /57/method/11

```text
selectDatabase([parameter metadata absent]): @SQL.PostgreSQL
```

```json
{
  "name": "selectDatabase",
  "return": [
    {
      "type": "@SQL.PostgreSQL"
    }
  ]
}
```

## method: ZeyOS.selectSession

Source pointer: /57/method/12

```text
selectSession([parameter metadata absent]): @ZeyOS.ObjectUser | null
```

```json
{
  "name": "selectSession",
  "return": [
    {
      "type": "@ZeyOS.ObjectUser"
    },
    {
      "type": "null",
      "description": "if there is no session"
    }
  ]
}
```

## method: ZeyOS.sendFile

Source pointer: /57/method/13

```text
sendFile(string $path)
```

```json
{
  "name": "sendFile",
  "description": "Sends the content of a file as sole output on exit (if possible).",
  "param": [
    {
      "name": "path",
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.writeConfig

Source pointer: /57/method/14

```text
writeConfig(object $config)
```

```json
{
  "name": "writeConfig",
  "param": [
    {
      "name": "config",
      "type": "object"
    }
  ]
}
```

## constant: ZeyOS.BASEURL

Source pointer: /57/const/0

```json
{
  "name": "BASEURL",
  "type": "string",
  "description": "ZeyOS base URL"
}
```

## constant: ZeyOS.EXTURL

Source pointer: /57/const/1

```json
{
  "name": "EXTURL",
  "type": "string",
  "description": "ZeyOS external URL"
}
```

## constant: ZeyOS.LICENSEKEY

Source pointer: /57/const/2

```json
{
  "name": "LICENSEKEY",
  "type": "string",
  "description": "ZeyOS license key"
}
```

## constant: ZeyOS.VERSION

Source pointer: /57/const/3

```json
{
  "name": "VERSION",
  "type": "int",
  "description": "ZeyOS version number"
}
```

# Zymba reference: ZeyOS.AuditIterator

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/58
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.AuditIterator

Source pointer: /58

```json
{
  "name": "ZeyOS.AuditIterator",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.AuditIterator.construct

Source pointer: /58/method/0

```text
construct(?int $timestamp)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "timestamp",
      "type": "?int",
      "default": "now"
    }
  ]
}
```

## method: ZeyOS.AuditIterator.close

Source pointer: /58/method/1

```text
close([parameter metadata absent])
```

```json
{
  "name": "close"
}
```

## method: ZeyOS.AuditIterator.exit

Source pointer: /58/method/2

```text
exit([parameter metadata absent])
```

```json
{
  "name": "exit"
}
```

## method: ZeyOS.AuditIterator.hasMore

Source pointer: /58/method/3

```text
hasMore([parameter metadata absent]): bool
```

```json
{
  "name": "hasMore",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.AuditIterator.next

Source pointer: /58/method/4

```text
next([parameter metadata absent]): object | null
```

```json
{
  "name": "next",
  "return": [
    {
      "type": "object"
    },
    {
      "type": "null",
      "description": "if there are no more transactions"
    }
  ]
}
```

## method: ZeyOS.AuditIterator.reset

Source pointer: /58/method/5

```text
reset([parameter metadata absent]): this
```

```json
{
  "name": "reset",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.BinFile

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/59
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.BinFile

Source pointer: /59

```json
{
  "name": "ZeyOS.BinFile",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.BinFile.construct

Source pointer: /59/method/0

```text
construct(?int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "id",
      "type": "?int",
      "default": "new"
    }
  ]
}
```

## method: ZeyOS.BinFile.exists

Source pointer: /59/method/1

```text
exists([parameter metadata absent]): bool
```

```json
{
  "name": "exists",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.BinFile.getID

Source pointer: /59/method/2

```text
getID([parameter metadata absent]): int | null
```

```json
{
  "name": "getID",
  "return": [
    {
      "type": "int"
    },
    {
      "type": "null",
      "description": "if the file does not exist"
    }
  ]
}
```

## method: ZeyOS.BinFile.read

Source pointer: /59/method/3

```text
read([parameter metadata absent]): string
```

```json
{
  "name": "read",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.BinFile.readOut

Source pointer: /59/method/4

```text
readOut([parameter metadata absent]): this
```

```json
{
  "name": "readOut",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.BinFile.write

Source pointer: /59/method/5

```text
write(string $string): this
```

```json
{
  "name": "write",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.ExtData

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/60
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.ExtData

Source pointer: /60

```json
{
  "name": "ZeyOS.ExtData",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.ExtData.construct

Source pointer: /60/method/0

```text
construct(string $entity, int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "entity",
      "type": "string"
    },
    {
      "name": "id",
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.ExtData.clear

Source pointer: /60/method/1

```text
clear([parameter metadata absent]): this
```

```json
{
  "name": "clear",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ExtData.countFields

Source pointer: /60/method/2

```text
countFields([parameter metadata absent]): int
```

```json
{
  "name": "countFields",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.ExtData.getEntity

Source pointer: /60/method/3

```text
getEntity([parameter metadata absent]): string
```

```json
{
  "name": "getEntity",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.ExtData.getField

Source pointer: /60/method/4

```text
getField(string $name): ?string
```

```json
{
  "name": "getField",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "?string"
    }
  ]
}
```

## method: ZeyOS.ExtData.getID

Source pointer: /60/method/5

```text
getID([parameter metadata absent]): int
```

```json
{
  "name": "getID",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.ExtData.hasField

Source pointer: /60/method/6

```text
hasField(string $name): bool
```

```json
{
  "name": "hasField",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ExtData.listFieldNames

Source pointer: /60/method/7

```text
listFieldNames([parameter metadata absent]): object
```

```json
{
  "name": "listFieldNames",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: ZeyOS.ExtData.listFields

Source pointer: /60/method/8

```text
listFields([parameter metadata absent]): object
```

```json
{
  "name": "listFields",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: ZeyOS.ExtData.removeFields

Source pointer: /60/method/9

```text
removeFields(object $names): this
```

```json
{
  "name": "removeFields",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ExtData.setField

Source pointer: /60/method/10

```text
setField(string $name, ?string $value): this
```

```json
{
  "name": "setField",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "?string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ExtData.setFields

Source pointer: /60/method/11

```text
setFields(object $fields): this
```

```json
{
  "name": "setFields",
  "param": [
    {
      "name": "fields",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.KeyAuth

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/61
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: true. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.KeyAuth

Source pointer: /61

```json
{
  "name": "ZeyOS.KeyAuth",
  "static": true
}
```

## method: ZeyOS.KeyAuth.create

Source pointer: /61/method/0

```text
create(string $key): string
```

```json
{
  "name": "create",
  "param": [
    {
      "name": "key",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.KeyAuth.verify

Source pointer: /61/method/1

```text
verify(string $key): bool | null
```

```json
{
  "name": "verify",
  "param": [
    {
      "name": "key",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    },
    {
      "type": "null",
      "description": "if there is no proper authorization header"
    }
  ]
}
```

# Zymba reference: ZeyOS.NumFormat

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/62
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.NumFormat

Source pointer: /62

```json
{
  "name": "ZeyOS.NumFormat",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.NumFormat.construct

Source pointer: /62/method/0

```text
construct(string $name)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.NumFormat.getFormat

Source pointer: /62/method/1

```text
getFormat([parameter metadata absent]): string
```

```json
{
  "name": "getFormat",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.NumFormat.getName

Source pointer: /62/method/2

```text
getName([parameter metadata absent]): string
```

```json
{
  "name": "getName",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.NumFormat.getNumber

Source pointer: /62/method/3

```text
getNumber([parameter metadata absent]): string
```

```json
{
  "name": "getNumber",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.NumFormat.incrementCounter

Source pointer: /62/method/4

```text
incrementCounter(int $offset): int
```

```json
{
  "name": "incrementCounter",
  "param": [
    {
      "name": "offset",
      "type": "int",
      "default": "1"
    }
  ],
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.NumFormat.nextNumber

Source pointer: /62/method/5

```text
nextNumber([parameter metadata absent]): string
```

```json
{
  "name": "nextNumber",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: ZeyOS.Object

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/63
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.Object

Source pointer: /63

```json
{
  "name": "ZeyOS.Object",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.Object.construct

Source pointer: /63/method/0

```text
construct(string $entity, ?int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "entity",
      "type": "string"
    },
    {
      "name": "id",
      "type": "?int",
      "default": "new"
    }
  ]
}
```

## method: ZeyOS.Object.addTags

Source pointer: /63/method/1

```text
addTags(object $names): this
```

```json
{
  "name": "addTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.canDelete

Source pointer: /63/method/2

```text
canDelete([parameter metadata absent]): bool
```

```json
{
  "name": "canDelete",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.clear

Source pointer: /63/method/3

```text
clear([parameter metadata absent]): this
```

```json
{
  "name": "clear",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.delete

Source pointer: /63/method/4

```text
delete([parameter metadata absent]): bool
```

```json
{
  "name": "delete",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.erase

Source pointer: /63/method/5

```text
erase(?function $callback): bool
```

```json
{
  "name": "erase",
  "param": [
    {
      "name": "callback",
      "type": "?function",
      "default": "no callback"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.eraseRaw

Source pointer: /63/method/6

```text
eraseRaw([parameter metadata absent]): bool
```

```json
{
  "name": "eraseRaw",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.exists

Source pointer: /63/method/7

```text
exists([parameter metadata absent]): bool
```

```json
{
  "name": "exists",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.getEntity

Source pointer: /63/method/8

```text
getEntity([parameter metadata absent]): string
```

```json
{
  "name": "getEntity",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.Object.getField

Source pointer: /63/method/9

```text
getField(string $name): ?string
```

```json
{
  "name": "getField",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "?string"
    }
  ]
}
```

## method: ZeyOS.Object.getFieldArray

Source pointer: /63/method/10

```text
getFieldArray(string $name): ?object
```

```json
{
  "name": "getFieldArray",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "?object"
    }
  ]
}
```

## method: ZeyOS.Object.getFieldJSON

Source pointer: /63/method/11

```text
getFieldJSON(string $name): ?object
```

```json
{
  "name": "getFieldJSON",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "?object"
    }
  ]
}
```

## method: ZeyOS.Object.getID

Source pointer: /63/method/12

```text
getID([parameter metadata absent]): int | null
```

```json
{
  "name": "getID",
  "return": [
    {
      "type": "int"
    },
    {
      "type": "null",
      "description": "if the object is not persistent"
    }
  ]
}
```

## method: ZeyOS.Object.hasAccess

Source pointer: /63/method/13

```text
hasAccess(bool $writable): bool
```

```json
{
  "name": "hasAccess",
  "param": [
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.hasField

Source pointer: /63/method/14

```text
hasField(string $name): bool
```

```json
{
  "name": "hasField",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Object.listExtData

Source pointer: /63/method/15

```text
listExtData([parameter metadata absent]): object
```

```json
{
  "name": "listExtData",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: ZeyOS.Object.listFieldNames

Source pointer: /63/method/16

```text
listFieldNames([parameter metadata absent]): object
```

```json
{
  "name": "listFieldNames",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: ZeyOS.Object.listFields

Source pointer: /63/method/17

```text
listFields([parameter metadata absent]): object
```

```json
{
  "name": "listFields",
  "return": [
    {
      "type": "object",
      "value": "[name: value, ...]"
    }
  ]
}
```

## method: ZeyOS.Object.listTags

Source pointer: /63/method/18

```text
listTags([parameter metadata absent]): object
```

```json
{
  "name": "listTags",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: ZeyOS.Object.readBinFile

Source pointer: /63/method/19

```text
readBinFile(string $name): string
```

```json
{
  "name": "readBinFile",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.Object.reload

Source pointer: /63/method/20

```text
reload([parameter metadata absent]): this
```

```json
{
  "name": "reload",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.removeFields

Source pointer: /63/method/21

```text
removeFields(object $names): this
```

```json
{
  "name": "removeFields",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.removeTags

Source pointer: /63/method/22

```text
removeTags(object $names): this
```

```json
{
  "name": "removeTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.resetTags

Source pointer: /63/method/23

```text
resetTags(object $names): this
```

```json
{
  "name": "resetTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.save

Source pointer: /63/method/24

```text
save(?function $callback, object $extdata, object $tags): this
```

```json
{
  "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"
    }
  ]
}
```

## method: ZeyOS.Object.saveRaw

Source pointer: /63/method/25

```text
saveRaw([parameter metadata absent]): this
```

```json
{
  "name": "saveRaw",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.selectExtData

Source pointer: /63/method/26

```text
selectExtData([parameter metadata absent]): @ZeyOS.ExtData | null
```

```json
{
  "name": "selectExtData",
  "return": [
    {
      "type": "@ZeyOS.ExtData"
    },
    {
      "type": "null",
      "description": "if the object is not persistent"
    }
  ]
}
```

## method: ZeyOS.Object.selectTags

Source pointer: /63/method/27

```text
selectTags([parameter metadata absent]): @ZeyOS.Tags | null
```

```json
{
  "name": "selectTags",
  "return": [
    {
      "type": "@ZeyOS.Tags"
    },
    {
      "type": "null",
      "description": "if the object is not persistent"
    }
  ]
}
```

## method: ZeyOS.Object.setExtData

Source pointer: /63/method/28

```text
setExtData(object $fields): this
```

```json
{
  "name": "setExtData",
  "param": [
    {
      "name": "fields",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.setField

Source pointer: /63/method/29

```text
setField(string $name, ?string $value): this
```

```json
{
  "name": "setField",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "?string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.setFieldArray

Source pointer: /63/method/30

```text
setFieldArray(string $name, ?object $array): this
```

```json
{
  "name": "setFieldArray",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "array",
      "type": "?object",
      "value": "[value, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.setFieldEncrypted

Source pointer: /63/method/31

```text
setFieldEncrypted(string $name, ?string $value): this
```

```json
{
  "name": "setFieldEncrypted",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "value",
      "type": "?string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.setFieldJSON

Source pointer: /63/method/32

```text
setFieldJSON(string $name, ?object $array): this
```

```json
{
  "name": "setFieldJSON",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "array",
      "type": "?object"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.setFields

Source pointer: /63/method/33

```text
setFields(object $fields): this
```

```json
{
  "name": "setFields",
  "param": [
    {
      "name": "fields",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Object.writeBinFile

Source pointer: /63/method/34

```text
writeBinFile(string $name, string $data): this
```

```json
{
  "name": "writeBinFile",
  "param": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "data",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.ObjectTransaction

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/64
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.ObjectTransaction

Source pointer: /64

```json
{
  "name": "ZeyOS.ObjectTransaction",
  "static": false,
  "extend": "ZeyOS.Object"
}
```

## method: ZeyOS.ObjectTransaction.construct

Source pointer: /64/method/0

```text
construct(?int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "id",
      "type": "?int",
      "default": "new"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.book

Source pointer: /64/method/1

```text
book([parameter metadata absent]): bool
```

```json
{
  "name": "book",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.calculateTaxes

Source pointer: /64/method/2

```text
calculateTaxes([parameter metadata absent]): object
```

```json
{
  "name": "calculateTaxes",
  "return": [
    {
      "type": "object",
      "value": "[[taxrate: ..., totalnet: ..., totalgross: ..., tax: ...], ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.calculateTotals

Source pointer: /64/method/3

```text
calculateTotals([parameter metadata absent]): object
```

```json
{
  "name": "calculateTotals",
  "return": [
    {
      "type": "object",
      "value": "[discount: ..., netamount: ..., tax:: ..., costs: ..., weight: ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.canCancel

Source pointer: /64/method/4

```text
canCancel([parameter metadata absent]): bool
```

```json
{
  "name": "canCancel",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.cancel

Source pointer: /64/method/5

```text
cancel([parameter metadata absent]): bool
```

```json
{
  "name": "cancel",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.canClose

Source pointer: /64/method/6

```text
canClose([parameter metadata absent]): bool
```

```json
{
  "name": "canClose",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.close

Source pointer: /64/method/7

```text
close([parameter metadata absent]): bool
```

```json
{
  "name": "close",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.fromEinvoice

Source pointer: /64/method/8

```text
fromEinvoice(string $document): object
```

```json
{
  "name": "fromEinvoice",
  "param": [
    {
      "name": "document",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.fromXML

Source pointer: /64/method/9

```text
fromXML(string $xml): object
```

```json
{
  "name": "fromXML",
  "param": [
    {
      "name": "xml",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.getBalance

Source pointer: /64/method/10

```text
getBalance([parameter metadata absent]): float
```

```json
{
  "name": "getBalance",
  "return": [
    {
      "type": "float"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.getItems

Source pointer: /64/method/11

```text
getItems([parameter metadata absent]): object
```

```json
{
  "name": "getItems",
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.isBilling

Source pointer: /64/method/12

```text
isBilling([parameter metadata absent]): bool
```

```json
{
  "name": "isBilling",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.isProcurement

Source pointer: /64/method/13

```text
isProcurement([parameter metadata absent]): bool
```

```json
{
  "name": "isProcurement",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.isProduction

Source pointer: /64/method/14

```text
isProduction([parameter metadata absent]): bool
```

```json
{
  "name": "isProduction",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.process

Source pointer: /64/method/15

```text
process(object $fields, object $serials): bool
```

```json
{
  "name": "process",
  "param": [
    {
      "name": "fields",
      "type": "object",
      "value": "[name: value, ...]"
    },
    {
      "name": "serials",
      "type": "object",
      "value": "[serialnum, ...]"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.setItems

Source pointer: /64/method/16

```text
setItems(object $items): this
```

```json
{
  "name": "setItems",
  "param": [
    {
      "name": "items",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.toEinvoice

Source pointer: /64/method/17

```text
toEinvoice(object $extra): string
```

```json
{
  "name": "toEinvoice",
  "param": [
    {
      "name": "extra",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.ObjectTransaction.toXML

Source pointer: /64/method/18

```text
toXML(string $format, string $context, object $extra): string
```

```json
{
  "name": "toXML",
  "param": [
    {
      "name": "format",
      "type": "string",
      "default": "\"CII\""
    },
    {
      "name": "context",
      "type": "string"
    },
    {
      "name": "extra",
      "type": "object",
      "value": "[name: value, ...]"
    }
  ],
  "return": [
    {
      "type": "string"
    }
  ]
}
```

# Zymba reference: ZeyOS.ObjectUser

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/65
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.ObjectUser

Source pointer: /65

```json
{
  "name": "ZeyOS.ObjectUser",
  "static": false,
  "extend": "ZeyOS.Object"
}
```

## method: ZeyOS.ObjectUser.construct

Source pointer: /65/method/0

```text
construct(?int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "id",
      "type": "?int",
      "default": "new"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.getLang

Source pointer: /65/method/1

```text
getLang([parameter metadata absent]): string
```

```json
{
  "name": "getLang",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.getLastLogin

Source pointer: /65/method/2

```text
getLastLogin([parameter metadata absent]): int | null
```

```json
{
  "name": "getLastLogin",
  "return": [
    {
      "type": "int"
    },
    {
      "type": "null",
      "description": "if there was no login yet"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.getSettings

Source pointer: /65/method/3

```text
getSettings([parameter metadata absent]): object
```

```json
{
  "name": "getSettings",
  "return": [
    {
      "type": "object"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.hasAccessTo

Source pointer: /65/method/4

```text
hasAccessTo(@ZeyOS.Object $object, bool $writable): bool
```

```json
{
  "name": "hasAccessTo",
  "param": [
    {
      "name": "object",
      "type": "@ZeyOS.Object"
    },
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.hasPermission

Source pointer: /65/method/5

```text
hasPermission(string $identifier, bool $writable): bool
```

```json
{
  "name": "hasPermission",
  "param": [
    {
      "name": "identifier",
      "type": "string"
    },
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.hasPermissionApp

Source pointer: /65/method/6

```text
hasPermissionApp(int $id, bool $writable): bool
```

```json
{
  "name": "hasPermissionApp",
  "param": [
    {
      "name": "id",
      "type": "int"
    },
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.hasPermissionFork

Source pointer: /65/method/7

```text
hasPermissionFork(int $id, bool $writable): bool
```

```json
{
  "name": "hasPermissionFork",
  "param": [
    {
      "name": "id",
      "type": "int"
    },
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.inGroup

Source pointer: /65/method/8

```text
inGroup(int $id, bool $writable): bool
```

```json
{
  "name": "inGroup",
  "param": [
    {
      "name": "id",
      "type": "int"
    },
    {
      "name": "writable",
      "type": "bool"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.isAdmin

Source pointer: /65/method/9

```text
isAdmin([parameter metadata absent]): bool
```

```json
{
  "name": "isAdmin",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.isApiOnly

Source pointer: /65/method/10

```text
isApiOnly([parameter metadata absent]): bool
```

```json
{
  "name": "isApiOnly",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.isNoPublic

Source pointer: /65/method/11

```text
isNoPublic([parameter metadata absent]): bool
```

```json
{
  "name": "isNoPublic",
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.listGroups

Source pointer: /65/method/12

```text
listGroups([parameter metadata absent]): object
```

```json
{
  "name": "listGroups",
  "return": [
    {
      "type": "object",
      "value": "[id: writable, ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.listPermissions

Source pointer: /65/method/13

```text
listPermissions([parameter metadata absent]): object
```

```json
{
  "name": "listPermissions",
  "return": [
    {
      "type": "object",
      "value": "[identifier: writable, ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.listPermittedApps

Source pointer: /65/method/14

```text
listPermittedApps([parameter metadata absent]): object
```

```json
{
  "name": "listPermittedApps",
  "return": [
    {
      "type": "object",
      "value": "[id: writable, ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.listPermittedForks

Source pointer: /65/method/15

```text
listPermittedForks([parameter metadata absent]): object
```

```json
{
  "name": "listPermittedForks",
  "return": [
    {
      "type": "object",
      "value": "[id: writable, ...]"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.setPassword

Source pointer: /65/method/16

```text
setPassword(string $password): this
```

```json
{
  "name": "setPassword",
  "param": [
    {
      "name": "password",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.setSettings

Source pointer: /65/method/17

```text
setSettings(object $settings): this
```

```json
{
  "name": "setSettings",
  "param": [
    {
      "name": "settings",
      "type": "object"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.ObjectUser.verifyPassword

Source pointer: /65/method/18

```text
verifyPassword(string $password): bool
```

```json
{
  "name": "verifyPassword",
  "param": [
    {
      "name": "password",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

# Zymba reference: ZeyOS.Tags

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/66
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.Tags

Source pointer: /66

```json
{
  "name": "ZeyOS.Tags",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.Tags.construct

Source pointer: /66/method/0

```text
construct(string $entity, int $id)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "entity",
      "type": "string"
    },
    {
      "name": "id",
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.Tags.addTags

Source pointer: /66/method/1

```text
addTags(object $names): this
```

```json
{
  "name": "addTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Tags.clear

Source pointer: /66/method/2

```text
clear([parameter metadata absent]): this
```

```json
{
  "name": "clear",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Tags.countTags

Source pointer: /66/method/3

```text
countTags([parameter metadata absent]): int
```

```json
{
  "name": "countTags",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.Tags.getEntity

Source pointer: /66/method/4

```text
getEntity([parameter metadata absent]): string
```

```json
{
  "name": "getEntity",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.Tags.getID

Source pointer: /66/method/5

```text
getID([parameter metadata absent]): int
```

```json
{
  "name": "getID",
  "return": [
    {
      "type": "int"
    }
  ]
}
```

## method: ZeyOS.Tags.hasAllTags

Source pointer: /66/method/6

```text
hasAllTags(object $names): bool
```

```json
{
  "name": "hasAllTags",
  "annotation": [
    "This function returns true for an empty names list (vacuous truth)."
  ],
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Tags.hasAnyTags

Source pointer: /66/method/7

```text
hasAnyTags(object $names): bool
```

```json
{
  "name": "hasAnyTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Tags.hasTag

Source pointer: /66/method/8

```text
hasTag(string $name): bool
```

```json
{
  "name": "hasTag",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "bool"
    }
  ]
}
```

## method: ZeyOS.Tags.listTags

Source pointer: /66/method/9

```text
listTags([parameter metadata absent]): object
```

```json
{
  "name": "listTags",
  "return": [
    {
      "type": "object",
      "value": "[name, ...]"
    }
  ]
}
```

## method: ZeyOS.Tags.removeTags

Source pointer: /66/method/10

```text
removeTags(object $names): this
```

```json
{
  "name": "removeTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.Tags.resetTags

Source pointer: /66/method/11

```text
resetTags(object $names): this
```

```json
{
  "name": "resetTags",
  "param": [
    {
      "name": "names",
      "type": "object",
      "value": "[name, ...]"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.TempFile

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/67
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.TempFile

Source pointer: /67

```json
{
  "name": "ZeyOS.TempFile",
  "static": false,
  "extend": "Base"
}
```

## method: ZeyOS.TempFile.construct

Source pointer: /67/method/0

```text
construct(string $name)
```

```json
{
  "name": "construct",
  "param": [
    {
      "name": "name",
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.delete

Source pointer: /67/method/1

```text
delete([parameter metadata absent]): this
```

```json
{
  "name": "delete",
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.TempFile.getName

Source pointer: /67/method/2

```text
getName([parameter metadata absent]): string
```

```json
{
  "name": "getName",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.getPath

Source pointer: /67/method/3

```text
getPath([parameter metadata absent]): string
```

```json
{
  "name": "getPath",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.read

Source pointer: /67/method/4

```text
read([parameter metadata absent]): string
```

```json
{
  "name": "read",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.readJSON

Source pointer: /67/method/5

```text
readJSON([parameter metadata absent]): mixed
```

```json
{
  "name": "readJSON",
  "return": [
    {
      "type": "mixed"
    }
  ]
}
```

## method: ZeyOS.TempFile.reserve

Source pointer: /67/method/6

```text
reserve([parameter metadata absent]): string
```

```json
{
  "name": "reserve",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.toString

Source pointer: /67/method/7

```text
toString([parameter metadata absent]): string
```

```json
{
  "name": "toString",
  "return": [
    {
      "type": "string"
    }
  ]
}
```

## method: ZeyOS.TempFile.write

Source pointer: /67/method/8

```text
write(string $string): this
```

```json
{
  "name": "write",
  "param": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

## method: ZeyOS.TempFile.writeJSON

Source pointer: /67/method/9

```text
writeJSON(mixed $value): this
```

```json
{
  "name": "writeJSON",
  "param": [
    {
      "name": "value",
      "type": "mixed"
    }
  ],
  "return": [
    {
      "type": "this"
    }
  ]
}
```

# Zymba reference: ZeyOS.TransactionContext

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/68
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.TransactionContext

Source pointer: /68

```json
{
  "name": "ZeyOS.TransactionContext",
  "static": false,
  "extend": "Base",
  "description": "ZeyOS transaction context prototype."
}
```

## method: ZeyOS.TransactionContext.construct

Source pointer: /68/method/0

```text
construct([parameter metadata absent])
```

```json
{
  "name": "construct"
}
```

## method: ZeyOS.TransactionContext.enter

Source pointer: /68/method/1

```text
enter([parameter metadata absent])
```

```json
{
  "name": "enter"
}
```

## method: ZeyOS.TransactionContext.exit

Source pointer: /68/method/2

```text
exit(mixed $exception)
```

```json
{
  "name": "exit",
  "param": [
    {
      "name": "exception",
      "type": "mixed"
    }
  ]
}
```

# Zymba reference: ZeyOS.Warning

Source: https://cloud.zeyos.com/__doc/zymbaref.json; mirrored at /__doc/zymbaref.json#/69
Source SHA-256: 05a361c6ddc32e74f4a6dc16fd06f218210ff1b7ce57f26ca1994bfffc407915

This is a projection of the official JSON reference, not the deferred Zymba guide or a runtime test.
Namespace static: false. Inherited members are not expanded; follow the original extends/extend metadata.
Method signatures are display aids. Read the exact param/default/return metadata below; defaults may be descriptions rather than expressions. Absence does not establish requiredness.

## namespace: ZeyOS.Warning

Source pointer: /69

```json
{
  "name": "ZeyOS.Warning",
  "static": false,
  "extend": "Exception"
}
```