@ringozz/godot 0.1.0

package/gen/heap-types/GodotArray.ts

@@ -0,0 +1,615 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R } from '../../src/runtime.ts';
+import type { Callable, StringName, Variant } from './index.ts';
+
+/** Godot's Array type — lazy, indexed container. */
+export class GodotArray<T = any> extends GodotVar implements Iterable<T> {
+    constructor(...args: any[]) { super(28, ...args); }
+
+    get length(): number { return _C(this, 13608) as number; }
+
+    *[Symbol.iterator](): Iterator<T> {
+        const n = _C(this, 13608) as number;
+        for (let i = 0; i < n; i++) yield _C(this, 3652, i) as T;
+    }
+    /**
+     * Returns the number of elements in the array. Empty arrays (`[]`) always return `0`. See also {@link isEmpty}.
+     */
+    size(): number { return _C(this, 13608) as number; }
+
+    /**
+     * Returns `true` if the array is empty (`[]`). See also {@link size}.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    /**
+     * Removes all elements from the array. This is equivalent to using {@link resize} with a size of `0`.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns a hashed 32-bit integer value representing the array and its contents.
+     * **Note:** Arrays with equal hash values are *not* guaranteed to be the same, as a result of hash collisions. On the contrary, arrays with different hash values are guaranteed to be different.
+     */
+    hash(): number { return _C(this, 7487) as number; }
+
+    /**
+     * Assigns elements of another `array` into the array. Resizes the array to match `array`. Performs type conversions if the array is typed.
+     */
+    assign(array: GodotArray<T>): void { _C(this, 1604, array); }
+
+    /**
+     * Returns the element at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `null`.
+     * This method is similar (but not identical) to the `[]` operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.
+     */
+    get(index: number): T { return _C(this, 3652, index) as T; }
+
+    /**
+     * Sets the value of the element at the given `index` to the given `value`. This will not change the size of the array, it only changes the value at an index already in the array. This is the same as using the `[]` operator (`array[index] = value`).
+     */
+    set(index: number, value: T): void { _C(this, 10392, index, value); }
+
+    /**
+     * Appends an element at the end of the array. See also {@link pushFront}.
+     */
+    pushBack(value: T): void { _C(this, 9630, value); }
+
+    /**
+     * Adds an element at the beginning of the array. See also {@link pushBack}.
+     * **Note:** This method shifts every other element's index forward, which may have a noticeable performance cost, especially on larger arrays.
+     */
+    pushFront(value: T): void { _C(this, 9645, value); }
+
+    /**
+     * Appends `value` at the end of the array (alias of {@link pushBack}).
+     */
+    append(value: T): void { _C(this, 1512, value); }
+
+    /**
+     * Appends another `array` at the end of this array.
+     *
+     * ```text
+     *
+     * var numbers = [1, 2, 3]
+     * var extra = [4, 5, 6]
+     * numbers.append_array(extra)
+     * print(numbers) # Prints [1, 2, 3, 4, 5, 6]
+     *
+     * ```
+     */
+    appendArray(array: GodotArray<T>): void { _C(this, 1513, array); }
+
+    /**
+     * Sets the array's number of elements to `size`. If `size` is smaller than the array's current size, the elements at the end are removed. If `size` is greater, new default elements (usually `null`) are added, depending on the array's type.
+     * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@link ERR_LOCKED} if the array is read-only, {@link ERR_INVALID_PARAMETER} if the size is negative, or {@link ERR_OUT_OF_MEMORY} if allocations fail. Use {@link size} to find the actual size of the array after resize.
+     * **Note:** Calling this method once and assigning the new values is faster than calling {@link append} for every new element.
+     */
+    resize(size: number): number { return _C(this, 10077, size) as number; }
+
+    /**
+     * Inserts a new element (`value`) at a given index (`position`) in the array. `position` should be between `0` and the array's {@link size}. If negative, `position` is considered relative to the end of the array.
+     * Returns {@link OK} on success, or one of the other {@link Error} constants if this method fails.
+     * **Note:** Every element's index after `position` needs to be shifted forward, which may have a noticeable performance cost, especially on larger arrays.
+     */
+    insert(position: number, value: T): number { return _C(this, 7631, position, value) as number; }
+
+    /**
+     * Removes the element from the array at the given index (`position`). If the index is out of bounds, this method fails. If the index is negative, `position` is considered relative to the end of the array.
+     * If you need to return the removed element, use {@link popAt}. To remove an element by value, use {@link erase} instead.
+     * **Note:** This method shifts every element's index after `position` back, which may have a noticeable performance cost, especially on larger arrays.
+     */
+    removeAt(position: number): void { _C(this, 9886, position); }
+
+    /**
+     * Assigns the given `value` to all elements in the array.
+     * This method can often be combined with {@link resize} to create an array with a given size and initialized elements:
+     *
+     *
+     * ```gdscript
+     *
+     * var array = []
+     * array.resize(5)
+     * array.fill(2)
+     * print(array) # Prints [2, 2, 2, 2, 2]
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** If `value` is a {@link Variant} passed by reference ({@link Object}-derived, {@link Array}, {@link Dictionary}, etc.), the array will be filled with references to the same `value`, which are not duplicates.
+     */
+    fill(value: T): void { _C(this, 3260, value); }
+
+    /**
+     * Finds and removes the first occurrence of `value` from the array. If `value` does not exist in the array, nothing happens. To remove an element by index, use {@link removeAt} instead.
+     * **Note:** This method shifts every element's index after the removed `value` back, which may have a noticeable performance cost, especially on larger arrays.
+     * **Note:** Erasing elements while iterating over arrays is **not** supported and will result in unpredictable behavior.
+     */
+    erase(value: T): void { _C(this, 3154, value); }
+
+    /**
+     * Returns the first element of the array. If the array is empty, fails and returns `null`. See also {@link back}.
+     * **Note:** Unlike with the `[]` operator (`array[0]`), an error is generated without stopping project execution.
+     */
+    front(): T { return _C(this, 3606) as T; }
+
+    /**
+     * Returns the last element of the array. If the array is empty, fails and returns `null`. See also {@link front}.
+     * **Note:** Unlike with the `[]` operator (`array[-1]`), an error is generated without stopping project execution.
+     */
+    back(): T { return _C(this, 1688) as T; }
+
+    /**
+     * Returns a random element from the array. Generates an error and returns `null` if the array is empty.
+     *
+     *
+     * ```gdscript
+     *
+     * # May print 1, 2, 3.25, or "Hi".
+     * print([1, 2, 3.25, "Hi"].pick_random())
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** Like many similar functions in the engine (such as {@link randi} or {@link shuffle}), this method uses a common, global random seed. To get a predictable outcome from this method, see {@link seed}.
+     */
+    pickRandom(): T { return _C(this, 9417) as T; }
+
+    /**
+     * Returns the index of the **first** occurrence of `what` in this array, or `-1` if there are none. The search's start can be specified with `from`, continuing to the end of the array.
+     * **Note:** If you just want to know whether the array contains `what`, use {@link has} (`Contains` in C#). In GDScript, you may also use the `in` operator.
+     * **Note:** For performance reasons, the search is affected by `what`'s {@link Variant.Type}. For example, `7` ({@link int}) and `7.0` ({@link float}) are not considered equal for this method.
+     */
+    find(what: T, from?: number /* = 0 */): number { return _C(this, 3276, what, from) as number; }
+
+    /**
+     * Returns the index of the **first** element in the array that causes `method` to return `true`, or `-1` if there are none. The search's start can be specified with `from`, continuing to the end of the array.
+     * `method` is a callable that takes an element of the array, and returns a {@link bool}.
+     * **Note:** If you just want to know whether the array contains *anything* that satisfies `method`, use {@link any}.
+     *
+     *
+     * ```gdscript
+     *
+     * func is_even(number):
+     * 	return number % 2 == 0
+     *
+     * func _ready():
+     * 	print([1, 3, 4, 7].find_custom(is_even.bind())) # Prints 2
+     *
+     * # Another example using `bind()` to pass an additional parameter:
+     * func is_specific_number(number, expected):
+     * 	return number == expected
+     *
+     * func _ready():
+     * 	print([1, 3, 4, 7].find_custom(is_specific_number.bind(4))) # Prints 2
+     *
+     * ```
+     */
+    findCustom(method: Callable, from?: number /* = 0 */): number { return _C(this, 3286, method, from) as number; }
+
+    /**
+     * Returns the index of the **last** occurrence of `what` in this array, or `-1` if there are none. The search's start can be specified with `from`, continuing to the beginning of the array. This method is the reverse of {@link find}.
+     */
+    rfind(what: T, from?: number /* = -1 */): number { return _C(this, 10108, what, from) as number; }
+
+    /**
+     * Returns the index of the **last** element of the array that causes `method` to return `true`, or `-1` if there are none. The search's start can be specified with `from`, continuing to the beginning of the array. This method is the reverse of {@link findCustom}.
+     */
+    rfindCustom(method: Callable, from?: number /* = -1 */): number { return _C(this, 10109, method, from) as number; }
+
+    /**
+     * Returns the number of times an element is in the array.
+     * To count how many elements in an array satisfy a condition, see {@link reduce}.
+     */
+    count(value: T): number { return _C(this, 2502, value) as number; }
+
+    /**
+     * Returns `true` if the array contains the given `value`.
+     *
+     *
+     * ```gdscript
+     *
+     * print(["inside", 7].has("inside"))  # Prints true
+     * print(["inside", 7].has("outside")) # Prints false
+     * print(["inside", 7].has(7))         # Prints true
+     * print(["inside", 7].has("7"))       # Prints false
+     *
+     * ```
+     *
+     *
+     *
+     * In GDScript, this is equivalent to the `in` operator:
+     *
+     * ```text
+     *
+     * if 4 in [2, 4, 6, 8]:
+     * 	print("4 is here!") # Will be printed.
+     *
+     * ```
+     *
+     * **Note:** For performance reasons, the search is affected by the `value`'s {@link Variant.Type}. For example, `7` ({@link int}) and `7.0` ({@link float}) are not considered equal for this method.
+     */
+    has(value: T): boolean { return _C(this, 7349, value) as boolean; }
+
+    /**
+     * Removes and returns the last element of the array. Returns `null` if the array is empty, without generating an error. See also {@link popFront}.
+     */
+    popBack(): T { return _C(this, 9478) as T; }
+
+    /**
+     * Removes and returns the first element of the array. Returns `null` if the array is empty, without generating an error. See also {@link popBack}.
+     * **Note:** This method shifts every other element's index back, which may have a noticeable performance cost, especially on larger arrays.
+     */
+    popFront(): T { return _C(this, 9480) as T; }
+
+    /**
+     * Removes and returns the element of the array at index `position`. If negative, `position` is considered relative to the end of the array. Returns `null` if the array is empty. If `position` is out of bounds, an error message is also generated.
+     * **Note:** This method shifts every element's index after `position` back, which may have a noticeable performance cost, especially on larger arrays.
+     */
+    popAt(position: number): T { return _C(this, 9477, position) as T; }
+
+    /**
+     * Sorts the array in ascending order. The final order is dependent on the "less than" (`<`) comparison between elements.
+     *
+     *
+     * ```gdscript
+     *
+     * var numbers = [10, 5, 2.5, 8]
+     * numbers.sort()
+     * print(numbers) # Prints [2.5, 5, 8, 10]
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability). This means that equivalent elements (such as `2` and `2.0`) may have their order changed when calling {@link sort}.
+     */
+    sort(): void { _C(this, 13723); }
+
+    /**
+     * Sorts the array using a custom {@link Callable}.
+     * `func` is called as many times as necessary, receiving two array elements as arguments. The function should return `true` if the first element should be moved *before* the second one, otherwise it should return `false`.
+     *
+     * ```text
+     *
+     * func sort_ascending(a, b):
+     * 	if a[1] < b[1]:
+     * 		return true
+     * 	return false
+     *
+     * func _ready():
+     * 	var my_items = [["Tomato", 5], ["Apple", 9], ["Rice", 4]]
+     * 	my_items.sort_custom(sort_ascending)
+     * 	print(my_items) # Prints [["Rice", 4], ["Tomato", 5], ["Apple", 9]]
+     *
+     * 	# Sort descending, using a lambda function.
+     * 	my_items.sort_custom(func(a, b): return a[1] > b[1])
+     * 	print(my_items) # Prints [["Apple", 9], ["Tomato", 5], ["Rice", 4]]
+     *
+     * ```
+     *
+     * It may also be necessary to use this method to sort strings by natural order, with {@link String.naturalnocasecmpTo}, as in the following example:
+     *
+     * ```text
+     *
+     * var files = ["newfile1", "newfile2", "newfile10", "newfile11"]
+     * files.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
+     * print(files) # Prints ["newfile1", "newfile2", "newfile10", "newfile11"]
+     *
+     * ```
+     *
+     * **Note:** In C#, this method is not supported.
+     * **Note:** The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability). This means that values considered equal may have their order changed when calling this method.
+     * **Note:** You should not randomize the return value of `func`, as the heapsort algorithm expects a consistent result. Randomizing the return value will result in unexpected behavior.
+     */
+    sortCustom(func: Callable): void { _C(this, 13725, func); }
+
+    /**
+     * Shuffles all elements of the array in a random order.
+     * **Note:** Like many similar functions in the engine (such as {@link randi} or {@link pickRandom}), this method uses a common, global random seed. To get a predictable outcome from this method, see {@link seed}.
+     */
+    shuffle(): void { _C(this, 13594); }
+
+    /**
+     * Returns the index of `value` in the sorted array. If it cannot be found, returns where `value` should be inserted to keep the array sorted. The algorithm used is [binary search](https://en.wikipedia.org/wiki/Binary_search_algorithm).
+     * If `before` is `true` (as by default), the returned index comes before all existing elements equal to `value` in the array.
+     *
+     * ```text
+     *
+     * var numbers = [2, 4, 8, 10]
+     * var idx = numbers.bsearch(7)
+     *
+     * numbers.insert(idx, 7)
+     * print(numbers) # Prints [2, 4, 7, 8, 10]
+     *
+     * var fruits = ["Apple", "Lemon", "Lemon", "Orange"]
+     * print(fruits.bsearch("Lemon", true))  # Prints 1, points at the first "Lemon".
+     * print(fruits.bsearch("Lemon", false)) # Prints 3, points at "Orange".
+     *
+     * ```
+     *
+     * **Note:** Calling {@link bsearch} on an *unsorted* array will result in unexpected behavior. Use {@link sort} before calling this method.
+     */
+    bsearch(value: T, before?: boolean /* = true */): number { return _C(this, 1915, value, before) as number; }
+
+    /**
+     * Returns the index of `value` in the sorted array. If it cannot be found, returns where `value` should be inserted to keep the array sorted (using `func` for the comparisons). The algorithm used is [binary search](https://en.wikipedia.org/wiki/Binary_search_algorithm).
+     * Similar to {@link sortCustom}, `func` is called as many times as necessary, receiving one array element and `value` as arguments. The function should return `true` if the array element should be *behind* `value`, otherwise it should return `false`.
+     * If `before` is `true` (as by default), the returned index comes before all existing elements equal to `value` in the array.
+     *
+     * ```text
+     *
+     * func sort_by_amount(a, b):
+     * 	if a[1] < b[1]:
+     * 		return true
+     * 	return false
+     *
+     * func _ready():
+     * 	var my_items = [["Tomato", 2], ["Kiwi", 5], ["Rice", 9]]
+     *
+     * 	var apple = ["Apple", 5]
+     * 	# "Apple" is inserted before "Kiwi".
+     * 	my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)
+     *
+     * 	var banana = ["Banana", 5]
+     * 	# "Banana" is inserted after "Kiwi".
+     * 	my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)
+     *
+     * 	# Prints [["Tomato", 2], ["Apple", 5], ["Kiwi", 5], ["Banana", 5], ["Rice", 9]]
+     * 	print(my_items)
+     *
+     * ```
+     *
+     * **Note:** Calling {@link bsearchCustom} on an *unsorted* array will result in unexpected behavior. Use {@link sortCustom} with `func` before calling this method.
+     */
+    bsearchCustom(value: T, func: Callable, before?: boolean /* = true */): number { return _C(this, 1916, value, func, before) as number; }
+
+    /**
+     * Reverses the order of all elements in the array.
+     */
+    reverse(): void { _C(this, 10104); }
+
+    /**
+     * Returns a new copy of the array.
+     * By default, a **shallow** copy is returned: all nested {@link Array}, {@link Dictionary}, and {@link Resource} elements are shared with the original array. Modifying any of those in one array will also affect them in the other.
+     * If `deep` is `true`, a **deep** copy is returned: all nested arrays and dictionaries are also duplicated (recursively). Any {@link Resource} is still shared with the original array, though.
+     */
+    duplicate(deep?: boolean /* = false */): GodotArray<T> { return _C(this, 2980, deep) as GodotArray<T>; }
+
+    /**
+     * Duplicates this array, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
+     * `deepSubresourcesMode` must be one of the values from {@link Resource.DeepDuplicateMode}. By default, only internal resources will be duplicated (recursively).
+     */
+    duplicateDeep(deepSubresourcesMode?: number /* = 1 */): GodotArray<T> { return _C(this, 2982, deepSubresourcesMode) as GodotArray<T>; }
+
+    /**
+     * Returns a new {@link Array} containing this array's elements, from index `begin` (inclusive) to `end` (exclusive), every `step` elements.
+     * If either `begin` or `end` are negative, their value is relative to the end of the array.
+     * If `step` is negative, this method iterates through the array in reverse, returning a slice ordered backwards. For this to work, `begin` must be greater than `end`.
+     * If `deep` is `true`, all nested {@link Array} and {@link Dictionary} elements in the slice are duplicated from the original, recursively. See also {@link duplicate}.
+     *
+     * ```text
+     *
+     * var letters = ["A", "B", "C", "D", "E", "F"]
+     *
+     * print(letters.slice(0, 2))  # Prints ["A", "B"]
+     * print(letters.slice(2, -2)) # Prints ["C", "D"]
+     * print(letters.slice(-2, 6)) # Prints ["E", "F"]
+     *
+     * print(letters.slice(0, 6, 2))  # Prints ["A", "C", "E"]
+     * print(letters.slice(4, 1, -1)) # Prints ["E", "D", "C"]
+     *
+     * ```
+     */
+    slice(begin: number, end?: number /* = 2147483647 */, step?: number /* = 1 */, deep?: boolean /* = false */): GodotArray<T> { return _C(this, 13658, begin, end, step, deep) as GodotArray<T>; }
+
+    /**
+     * Calls the given {@link Callable} on each element in the array and returns a new, filtered {@link Array}.
+     * The `method` receives one of the array elements as an argument, and should return `true` to add the element to the filtered array, or `false` to exclude it.
+     *
+     * ```text
+     *
+     * func is_even(number):
+     * 	return number % 2 == 0
+     *
+     * func _ready():
+     * 	print([1, 4, 5, 8].filter(is_even)) # Prints [4, 8]
+     *
+     * 	# Same as above, but using a lambda function.
+     * 	print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))
+     *
+     * ```
+     *
+     * See also {@link any}, {@link all}, {@link map} and {@link reduce}.
+     */
+    filter(method: Callable): GodotArray<T> { return _C(this, 3267, method) as GodotArray<T>; }
+
+    /**
+     * Calls the given {@link Callable} for each element in the array and returns a new array filled with values returned by the `method`.
+     * The `method` should take one {@link Variant} parameter (the current array element) and can return any {@link Variant}.
+     *
+     * ```text
+     *
+     * func double(number):
+     * 	return number * 2
+     *
+     * func _ready():
+     * 	print([1, 2, 3].map(double)) # Prints [2, 4, 6]
+     *
+     * 	# Same as above, but using a lambda function.
+     * 	print([1, 2, 3].map(func(element): return element * 2))
+     *
+     * ```
+     *
+     * See also {@link filter}, {@link reduce}, {@link any} and {@link all}.
+     */
+    map(method: Callable): GodotArray<T> { return _C(this, 8745, method) as GodotArray<T>; }
+
+    /**
+     * Calls the given {@link Callable} for each element in array, accumulates the result in `accum`, then returns it.
+     * The `method` takes two arguments: the current value of `accum` and the current array element. If `accum` is `null` (as by default), the iteration will start from the second element, with the first one used as initial value of `accum`.
+     *
+     * ```text
+     *
+     * func sum(accum, number):
+     * 	return accum + number
+     *
+     * func _ready():
+     * 	print([1, 2, 3].reduce(sum, 0))  # Prints 6
+     * 	print([1, 2, 3].reduce(sum, 10)) # Prints 16
+     *
+     * 	# Same as above, but using a lambda function.
+     * 	print([1, 2, 3].reduce(func(accum, number): return accum + number, 10))
+     *
+     * ```
+     *
+     * If {@link max} is not desirable, this method may also be used to implement a custom comparator:
+     *
+     * ```text
+     *
+     * func _ready():
+     * 	var arr = [Vector2i(5, 0), Vector2i(3, 4), Vector2i(1, 2)]
+     *
+     * 	var longest_vec = arr.reduce(func(max, vec): return vec if is_length_greater(vec, max) else max)
+     * 	print(longest_vec) # Prints (3, 4)
+     *
+     * func is_length_greater(a, b):
+     * 	return a.length() > b.length()
+     *
+     * ```
+     *
+     * This method can also be used to count how many elements in an array satisfy a certain condition, similar to {@link count}:
+     *
+     * ```text
+     *
+     * func is_even(number):
+     * 	return number % 2 == 0
+     *
+     * func _ready():
+     * 	var arr = [1, 2, 3, 4, 5]
+     * 	# If the current element is even, increment count, otherwise leave count the same.
+     * 	var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0)
+     * 	print(even_count) # Prints 2
+     *
+     * ```
+     *
+     * See also {@link map}, {@link filter}, {@link any}, and {@link all}.
+     */
+    reduce(method: Callable, accum?: T /* = null */): T { return _C(this, 9771, method, accum) as T; }
+
+    /**
+     * Calls the given {@link Callable} on each element in the array and returns `true` if the {@link Callable} returns `true` for *one or more* elements in the array. If the {@link Callable} returns `false` for all elements in the array, this method returns `false`.
+     * The `method` should take one {@link Variant} parameter (the current array element) and return a {@link bool}.
+     *
+     * ```text
+     *
+     * func greater_than_5(number):
+     * 	return number > 5
+     *
+     * func _ready():
+     * 	print([6, 10, 6].any(greater_than_5)) # Prints true (3 elements evaluate to true).
+     * 	print([4, 10, 4].any(greater_than_5)) # Prints true (1 elements evaluate to true).
+     * 	print([4, 4, 4].any(greater_than_5))  # Prints false (0 elements evaluate to true).
+     * 	print([].any(greater_than_5))         # Prints false (0 elements evaluate to true).
+     *
+     * 	# Same as the first line above, but using a lambda function.
+     * 	print([6, 10, 6].any(func(number): return number > 5)) # Prints true
+     *
+     * ```
+     *
+     * See also {@link all}, {@link filter}, {@link map} and {@link reduce}.
+     * **Note:** Unlike relying on the size of an array returned by {@link filter}, this method will return as early as possible to improve performance (especially with large arrays).
+     * **Note:** For an empty array, this method always returns `false`.
+     */
+    any(method: Callable): boolean { return _C(this, 1505, method) as boolean; }
+
+    /**
+     * Calls the given {@link Callable} on each element in the array and returns `true` if the {@link Callable} returns `true` for *all* elements in the array. If the {@link Callable} returns `false` for one array element or more, this method returns `false`.
+     * The `method` should take one {@link Variant} parameter (the current array element) and return a {@link bool}.
+     *
+     *
+     * ```gdscript
+     *
+     * func greater_than_5(number):
+     * 	return number > 5
+     *
+     * func _ready():
+     * 	print([6, 10, 6].all(greater_than_5)) # Prints true (3/3 elements evaluate to true).
+     * 	print([4, 10, 4].all(greater_than_5)) # Prints false (1/3 elements evaluate to true).
+     * 	print([4, 4, 4].all(greater_than_5))  # Prints false (0/3 elements evaluate to true).
+     * 	print([].all(greater_than_5))         # Prints true (0/0 elements evaluate to true).
+     *
+     * 	# Same as the first line above, but using a lambda function.
+     * 	print([6, 10, 6].all(func(element): return element > 5)) # Prints true
+     *
+     * ```
+     *
+     *
+     *
+     * See also {@link any}, {@link filter}, {@link map} and {@link reduce}.
+     * **Note:** Unlike relying on the size of an array returned by {@link filter}, this method will return as early as possible to improve performance (especially with large arrays).
+     * **Note:** For an empty array, this method [always](https://en.wikipedia.org/wiki/Vacuous_truth) returns `true`.
+     */
+    all(method: Callable): boolean { return _C(this, 1407, method) as boolean; }
+
+    /**
+     * Returns the maximum value contained in the array, if all elements can be compared. Otherwise, returns `null`. See also {@link min}.
+     * To find the maximum value using a custom comparator, you can use {@link reduce}.
+     */
+    max(): T { return _C(this, 8804) as T; }
+
+    /**
+     * Returns the minimum value contained in the array, if all elements can be compared. Otherwise, returns `null`. See also {@link max}.
+     */
+    min(): T { return _C(this, 8910) as T; }
+
+    /**
+     * Returns `true` if the array is typed. Typed arrays can only contain elements of a specific type, as defined by the typed array constructor. The methods of a typed array are still expected to return a generic {@link Variant}.
+     * In GDScript, it is possible to define a typed array with static typing:
+     *
+     * ```text
+     *
+     * var numbers: Array[float] = [0.2, 4.2, -2.0]
+     * print(numbers.is_typed()) # Prints true
+     *
+     * ```
+     */
+    isTyped(): boolean { return _C(this, 8379) as boolean; }
+
+    /**
+     * Returns `true` if this array is typed the same as the given `array`. See also {@link isTyped}.
+     */
+    isSameTyped(array: GodotArray<T>): boolean { return _C(this, 8261, array) as boolean; }
+
+    /**
+     * Returns the built-in {@link Variant} type of the typed array as a {@link Variant.Type} constant. If the array is not typed, returns {@link TYPE_NIL}. See also {@link isTyped}.
+     */
+    getTypedBuiltin(): number { return _C(this, 6926) as number; }
+
+    /**
+     * Returns the **built-in** class name of the typed array, if the built-in {@link Variant} type {@link TYPE_OBJECT}. Otherwise, returns an empty {@link StringName}. See also {@link isTyped} and {@link Object.getClass}.
+     */
+    getTypedClassName(): StringName { return _C(this, 6927) as StringName; }
+
+    /**
+     * Returns the {@link Script} instance associated with this typed array, or `null` if it does not exist. See also {@link isTyped}.
+     */
+    getTypedScript(): T { return _C(this, 6931) as T; }
+
+    /**
+     * Makes the array read-only. The array's elements cannot be overridden with different values, and their order cannot change. Does not apply to nested elements, such as dictionaries.
+     * In GDScript, arrays are automatically read-only if declared with the `const` keyword.
+     */
+    makeReadOnly(): void { _C(this, 8738); }
+
+    /**
+     * Returns `true` if the array is read-only. See {@link makeReadOnly}.
+     * In GDScript, arrays are automatically read-only if declared with the `const` keyword.
+     */
+    isReadOnly(): boolean { return _C(this, 8227) as boolean; }
+
+    static readonly name = _R(28, GodotArray);
+}