gdext/arraytools

Search:
Group by:

Array

A standard collection of Variants provided by Godot that holds values of any type whose conversion to Variant is supported.

TypedArray[SomeVariant]

Array that to be statically typed. Internally, it is the same as Array since that uses Variant for the element type, but the type is statically checked. (Attempting to add a Texture2D to a TypedArray[Node] will result in a compile error.)

A good alternative if you want to use Array's API under a static type system.

PackedArray

A primitive dynamic array provided by Godot.

Procs

func `&`(x, y: Array): Array {.inline, ...raises: [], tags: [RootEffect],
                               forbids: [].}
proc `&`(x: Array; y: Variant): Array {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc `&`(x: Variant; y: Array): Array {....raises: [], tags: [RootEffect],
                                        forbids: [].}
func `&`[T](x, y: PackedArray[T]) {.inline.}
func `&`[T](x, y: TypedArray[T]): TypedArray[T] {.inline.}
proc `&`[T](x: PackedArray; y: T): PackedArray[T]
proc `&`[T](x: T; y: PackedArray): PackedArray[T]
proc `&`[T](x: T; y: TypedArray): TypedArray[T]
proc `&`[T](x: TypedArray; y: T): TypedArray[T]
func `*`(left: PackedVector2Array; right: Transform2D): PackedVector2Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `*`(left: PackedVector3Array; right: Transform3D): PackedVector3Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: Array; right: Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
func `+`(left: PackedByteArray; right: PackedByteArray): PackedByteArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedColorArray; right: PackedColorArray): PackedColorArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedFloat32Array; right: PackedFloat32Array): PackedFloat32Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedFloat64Array; right: PackedFloat64Array): PackedFloat64Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedInt32Array; right: PackedInt32Array): PackedInt32Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedInt64Array; right: PackedInt64Array): PackedInt64Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedStringArray; right: PackedStringArray): PackedStringArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedVector2Array; right: PackedVector2Array): PackedVector2Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedVector3Array; right: PackedVector3Array): PackedVector3Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: PackedVector4Array; right: PackedVector4Array): PackedVector4Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `<`(left: Array; right: Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `<=`(left: Array; right: Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `==`(left: Array; right: Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `==`(left: PackedByteArray; right: PackedByteArray): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
func `==`(left: PackedColorArray; right: PackedColorArray): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
func `==`(left: PackedFloat32Array; right: PackedFloat32Array): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `==`(left: PackedFloat64Array; right: PackedFloat64Array): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `==`(left: PackedInt32Array; right: PackedInt32Array): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
func `==`(left: PackedInt64Array; right: PackedInt64Array): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
func `==`(left: PackedStringArray; right: PackedStringArray): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
func `==`(left: PackedVector2Array; right: PackedVector2Array): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `==`(left: PackedVector3Array; right: PackedVector3Array): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `==`(left: PackedVector4Array; right: PackedVector4Array): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc `@`[T](arr: PackedArray[T]): seq[T]
proc `[]`(arr: Array; index: BackwardsIndex): Variant {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc `[]`(arr: var Array; index: BackwardsIndex): var Variant {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc `[]`(self: Array; index: Natural): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `[]`(self: var Array; index: Natural): var Variant {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `[]`[T: SomeBuiltins](self: var TypedArray[T]; index: Natural): var T
proc `[]`[T; U, V: Ordinal](arr: PackedArray[T]; x: HSlice[U, V]): PackedArray[T] {.
    inline.}
proc `[]`[T; U, V: Ordinal](arr: TypedArray[T]; x: HSlice[U, V]): TypedArray[T] {.
    inline.}
proc `[]`[T](arr: PackedArray[T]; index: BackwardsIndex): T {.inline.}
proc `[]`[T](arr: TypedArray[T]; index: BackwardsIndex): T {.inline.}
proc `[]`[T](arr: var PackedArray[T]; index: BackwardsIndex): var T {.inline.}
proc `[]`[T](arr: var TypedArray[T]; index: BackwardsIndex): var T {.inline.}
proc `[]`[T](self: PackedArray[T]; index: Natural): T
proc `[]`[T](self: TypedArray[T]; index: Natural): T
proc `[]`[T](self: var PackedArray[T]; index: Natural): var T
proc `[]`[U, V: Ordinal](arr: Array; x: HSlice[U, V]): Array {.inline.}
proc `[]=`(arr: var Array; index: BackwardsIndex; value: Variant) {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc `[]=`(self: var Array; index: Natural; value: sink Variant) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `[]=`[T; U, V: Ordinal](s: var PackedArray[T]; x: HSlice[U, V];
                             b: PackedArray[T])
proc `[]=`[T; U, V: Ordinal](s: var TypedArray[T]; x: HSlice[U, V];
                             b: TypedArray[T])
proc `[]=`[T](arr: var PackedArray[T]; index: BackwardsIndex; value: T) {.inline.}
proc `[]=`[T](arr: var TypedArray[T]; index: BackwardsIndex; value: T) {.inline.}
proc `[]=`[T](self: var PackedArray[T]; index: Natural; value: sink T)
proc `[]=`[T](self: var TypedArray[T]; index: Natural; value: sink T)
proc `[]=`[U, V: Ordinal](s: var Array; x: HSlice[U, V]; b: Array)
proc add(self: var Array; array: Array) {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc add(self: var Array; value: Variant) {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc add[T](self: var PackedArray[T]; array: PackedArray[T]) {.inline.}
proc add[T](self: var PackedArray[T]; value: T) {.inline.}
proc add[T](self: var TypedArray[T]; value: T) {.inline.}
proc all(self: Array; method: Callable): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc any(self: Array; method: Callable): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc append(self: var Array; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedByteArray; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedColorArray; value: Color): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedFloat32Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedFloat64Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedInt32Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedInt64Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedStringArray; value: String): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedVector2Array; value: Vector2): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedVector3Array; value: Vector3): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append(self: var PackedVector4Array; value: Vector4): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc append[T](self: var TypedArray[T]; value: T): void
proc appendArray(self: var Array; array: Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedByteArray; array: PackedByteArray): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedColorArray; array: PackedColorArray): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedFloat32Array; array: PackedFloat32Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedFloat64Array; array: PackedFloat64Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedInt32Array; array: PackedInt32Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedInt64Array; array: PackedInt64Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedStringArray; array: PackedStringArray): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedVector2Array; array: PackedVector2Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedVector3Array; array: PackedVector3Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc appendArray(self: var PackedVector4Array; array: PackedVector4Array): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc assign(self: var Array; array: Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc back(self: Array): Variant {....raises: [], tags: [RootEffect], forbids: [].}
proc back[T](self: TypedArray[T]): T
proc bsearch(self: Array; value: Variant; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedByteArray; value: Int; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedColorArray; value: Color; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedFloat32Array; value: Float; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedFloat64Array; value: Float; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedInt32Array; value: Int; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedInt64Array; value: Int; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedStringArray; value: String; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedVector2Array; value: Vector2; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedVector3Array; value: Vector3; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch(self: var PackedVector4Array; value: Vector4; before: bool = true): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc bsearch[T](self: TypedArray[T]; value: T; before: bool = true): Int
proc bsearchCustom(self: Array; value: Variant; func: Callable;
                   before: bool = true): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc bsearchCustom[T](self: TypedArray[T]; value: T; func: Callable;
                      before: bool = true): Int
proc clear(self: var Array): void {....raises: [], tags: [RootEffect], forbids: [].}
proc clear(self: var PackedByteArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedColorArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedFloat32Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedFloat64Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedInt32Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedInt64Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedStringArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedVector2Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedVector3Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc clear(self: var PackedVector4Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc compress(self: PackedByteArray; compressionMode: Int = 0): PackedByteArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc contains(arr: Array; value: Variant): bool {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc contains[T: SomeProperty](arr: Array; value: T): bool {.inline.}
proc contains[T](arr: PackedArray[T]; item: T): bool {.inline.}
proc contains[T](arr: TypedArray[T]; value: T): bool {.inline.}
proc count(self: Array; value: Variant): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc count(self: PackedByteArray; value: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedColorArray; value: Color): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedFloat32Array; value: Float): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedFloat64Array; value: Float): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedInt32Array; value: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedInt64Array; value: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedStringArray; value: String): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedVector2Array; value: Vector2): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedVector3Array; value: Vector3): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count(self: PackedVector4Array; value: Vector4): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc count[T](self: TypedArray[T]; value: T): Int
proc decodeDouble(self: PackedByteArray; byteOffset: Int): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeFloat(self: PackedByteArray; byteOffset: Int): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeHalf(self: PackedByteArray; byteOffset: Int): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeS8(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeS16(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeS32(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeS64(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeU8(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeU16(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeU32(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeU64(self: PackedByteArray; byteOffset: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeVar(self: PackedByteArray; byteOffset: Int;
               allowObjects: bool = false): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decodeVarSize(self: PackedByteArray; byteOffset: Int;
                   allowObjects: bool = false): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc decompress(self: PackedByteArray; bufferSize: Int; compressionMode: Int = 0): PackedByteArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc decompressDynamic(self: PackedByteArray; maxOutputSize: Int;
                       compressionMode: Int = 0): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc delete(self: var Array; index: Natural) {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc delete[T](self: var PackedArray[T]; index: Natural) {.inline.}
proc duplicate(self: Array; deep: bool = false): Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedByteArray): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedColorArray): PackedColorArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedFloat32Array): PackedFloat32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedFloat64Array): PackedFloat64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedInt32Array): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedInt64Array): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedStringArray): PackedStringArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedVector2Array): PackedVector2Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedVector3Array): PackedVector3Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate(self: var PackedVector4Array): PackedVector4Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc duplicate[T](self: TypedArray[T]; deep: bool = false): TypedArray[T]
proc encodeDouble(self: var PackedByteArray; byteOffset: Int; value: Float): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeFloat(self: var PackedByteArray; byteOffset: Int; value: Float): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeHalf(self: var PackedByteArray; byteOffset: Int; value: Float): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeS8(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeS16(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeS32(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeS64(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeU8(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeU16(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeU32(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeU64(self: var PackedByteArray; byteOffset: Int; value: Int): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc encodeVar(self: var PackedByteArray; byteOffset: Int; value: Variant;
               allowObjects: bool = false): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc erase(self: var Array; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc erase[T](self: var TypedArray[T]; value: T): void
proc fill(self: var Array; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedByteArray; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedColorArray; value: Color): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedFloat32Array; value: Float): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedFloat64Array; value: Float): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedInt32Array; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedInt64Array; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedStringArray; value: String): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedVector2Array; value: Vector2): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedVector3Array; value: Vector3): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill(self: var PackedVector4Array; value: Vector4): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fill[T](self: var TypedArray[T]; value: T): void
proc filter(self: Array; method: Callable): Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc filter[T](self: TypedArray[T]; method: Callable): TypedArray[T]
proc find(self: Array; what: Variant; from: Int = 0): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc find(self: PackedByteArray; value: Int; from: Int = 0): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc find(self: PackedColorArray; value: Color; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedFloat32Array; value: Float; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedFloat64Array; value: Float; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedInt32Array; value: Int; from: Int = 0): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc find(self: PackedInt64Array; value: Int; from: Int = 0): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc find(self: PackedStringArray; value: String; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedVector2Array; value: Vector2; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedVector3Array; value: Vector3; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find(self: PackedVector4Array; value: Vector4; from: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc find[T](self: TypedArray[T]; what: T; from: Int = 0): Int
proc findCustom(self: Array; method: Callable; from: Int = 0): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc front(self: Array): Variant {....raises: [], tags: [RootEffect], forbids: [].}
proc front[T](self: TypedArray[T]): T
proc get(self: Array; index: Int): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}
proc get(self: PackedByteArray; index: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedColorArray; index: Int): Color {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedFloat32Array; index: Int): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedFloat64Array; index: Int): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedInt32Array; index: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedInt64Array; index: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedStringArray; index: Int): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedVector2Array; index: Int): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedVector3Array; index: Int): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get(self: PackedVector4Array; index: Int): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc get[T](self: TypedArray[T]; index: Int): T
proc getStringFromAscii(self: PackedByteArray): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getStringFromUtf8(self: PackedByteArray): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getStringFromUtf16(self: PackedByteArray): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getStringFromUtf32(self: PackedByteArray): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getStringFromWchar(self: PackedByteArray): String {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getTypedBuiltin(self: Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getTypedClassName(self: Array): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getTypedScript(self: Array): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}
proc has(self: Array; value: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc has(self: PackedByteArray; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedColorArray; value: Color): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedFloat32Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedFloat64Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedInt32Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedInt64Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedStringArray; value: String): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedVector2Array; value: Vector2): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedVector3Array; value: Vector3): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has(self: PackedVector4Array; value: Vector4): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc has[T](self: TypedArray[T]; value: T): bool
proc hasEncodedVar(self: PackedByteArray; byteOffset: Int;
                   allowObjects: bool = false): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc hash(self: Array): Hash {....raises: [], tags: [RootEffect], forbids: [].}
proc hexEncode(self: PackedByteArray): String {....raises: [], tags: [RootEffect],
    forbids: [].}
proc high(arr: Array): int {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc high(arr: PackedArray): int {.inline.}
proc insert(self: var Array; position: Int; value: Variant): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc insert(self: var PackedByteArray; atIndex: Int; value: Int): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedColorArray; atIndex: Int; value: Color): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedFloat32Array; atIndex: Int; value: Float): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedFloat64Array; atIndex: Int; value: Float): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedInt32Array; atIndex: Int; value: Int): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedInt64Array; atIndex: Int; value: Int): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedStringArray; atIndex: Int; value: String): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedVector2Array; atIndex: Int; value: Vector2): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedVector3Array; atIndex: Int; value: Vector3): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert(self: var PackedVector4Array; atIndex: Int; value: Vector4): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc insert[T](self: var TypedArray[T]; position: Int; value: T): Int
proc isEmpty(self: Array): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isEmpty(self: PackedByteArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedColorArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedFloat32Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedFloat64Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedInt32Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedInt64Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedStringArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedVector2Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedVector3Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEmpty(self: PackedVector4Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isReadOnly(self: Array): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isSameTyped(self: Array; array: Array): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isTyped(self: Array): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc len(arr: Array): int {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc len(arr: PackedArray): int {.inline.}
proc low(arr: Array): int {.inline, ...raises: [], tags: [], forbids: [].}
proc low(arr: PackedArray): int {.inline.}
proc makeReadOnly(self: var Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc map(self: Array; method: Callable): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc max(self: Array): Variant {....raises: [], tags: [RootEffect], forbids: [].}
proc max[T](self: TypedArray[T]): T
proc min(self: Array): Variant {....raises: [], tags: [RootEffect], forbids: [].}
proc min[T](self: TypedArray[T]): T
proc newArray(): Array {....raises: [], tags: [RootEffect], forbids: [].}
proc newArray(base: Array; type: Int; className: StringName; script: Variant): Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newArray(from: Array): Array {....raises: [], tags: [RootEffect], forbids: [].}
proc newArray(from: PackedByteArray): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedColorArray): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedFloat32Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedFloat64Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedInt32Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedInt64Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedStringArray): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedVector2Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedVector3Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(from: PackedVector4Array): Array {....raises: [], tags: [RootEffect],
    forbids: [].}
proc newArray(len: Natural): Array {....raises: [], tags: [RootEffect], forbids: [].}
proc newArray[T](s: openArray[T]): Array
proc newPackedArray(s: openArray[byte]): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[Color]): PackedColorArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[float32]): PackedFloat32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[float64]): PackedFloat64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[int32]): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[int64]): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[String]): PackedStringArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[Vector2]): PackedVector2Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[Vector3]): PackedVector3Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedArray(s: openArray[Vector4]): PackedVector4Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedByteArray(): PackedByteArray {....raises: [], tags: [], forbids: [].}
proc newPackedByteArray(from: Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedByteArray(from: PackedByteArray): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedByteArray(s: openArray[byte]): PackedByteArray {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedByteArray(size: int): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedColorArray(): PackedColorArray {....raises: [], tags: [], forbids: [].}
proc newPackedColorArray(from: Array): PackedColorArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedColorArray(from: PackedColorArray): PackedColorArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedColorArray(s: openArray[Color]): PackedColorArray {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedColorArray(size: int): PackedColorArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedFloat32Array(): PackedFloat32Array {....raises: [], tags: [],
    forbids: [].}
proc newPackedFloat32Array(from: Array): PackedFloat32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedFloat32Array(from: PackedFloat32Array): PackedFloat32Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedFloat32Array(s: openArray[float32]): PackedFloat32Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedFloat32Array(size: int): PackedFloat32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedFloat64Array(): PackedFloat64Array {....raises: [], tags: [],
    forbids: [].}
proc newPackedFloat64Array(from: Array): PackedFloat64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedFloat64Array(from: PackedFloat64Array): PackedFloat64Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedFloat64Array(s: openArray[float64]): PackedFloat64Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedFloat64Array(size: int): PackedFloat64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt32Array(): PackedInt32Array {....raises: [], tags: [], forbids: [].}
proc newPackedInt32Array(from: Array): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt32Array(from: PackedInt32Array): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt32Array(s: openArray[int32]): PackedInt32Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedInt32Array(size: int): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt64Array(): PackedInt64Array {....raises: [], tags: [], forbids: [].}
proc newPackedInt64Array(from: Array): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt64Array(from: PackedInt64Array): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedInt64Array(s: openArray[int64]): PackedInt64Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedInt64Array(size: int): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedStringArray(): PackedStringArray {....raises: [], tags: [],
    forbids: [].}
proc newPackedStringArray(from: Array): PackedStringArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedStringArray(from: PackedStringArray): PackedStringArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedStringArray(s: openArray[String]): PackedStringArray {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedStringArray(size: int): PackedStringArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector2Array(): PackedVector2Array {....raises: [], tags: [],
    forbids: [].}
proc newPackedVector2Array(from: Array): PackedVector2Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector2Array(from: PackedVector2Array): PackedVector2Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector2Array(s: openArray[Vector2]): PackedVector2Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector2Array(size: int): PackedVector2Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector3Array(): PackedVector3Array {....raises: [], tags: [],
    forbids: [].}
proc newPackedVector3Array(from: Array): PackedVector3Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector3Array(from: PackedVector3Array): PackedVector3Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector3Array(s: openArray[Vector3]): PackedVector3Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector3Array(size: int): PackedVector3Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector4Array(): PackedVector4Array {....raises: [], tags: [],
    forbids: [].}
proc newPackedVector4Array(from: Array): PackedVector4Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newPackedVector4Array(from: PackedVector4Array): PackedVector4Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector4Array(s: openArray[Vector4]): PackedVector4Array {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
proc newPackedVector4Array(size: int): PackedVector4Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc newTypedArray[T](): TypedArray[T]
proc newTypedArray[T](arr: Array): TypedArray[T]
proc newTypedArray[T](arr: TypedArray[T]): TypedArray[T]
proc newTypedArray[T](len: Natural): TypedArray[T]
proc newTypedArray[T](s: openArray[T]): TypedArray[T]
func `not`(left: Array): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: PackedByteArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedColorArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedFloat32Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedFloat64Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedInt32Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedInt64Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedStringArray): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedVector2Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedVector3Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func `not`(left: PackedVector4Array): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc pickRandom(self: Array): Variant {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc pickRandom[T](self: TypedArray[T]): T
proc pop(self: var Array): Variant {.inline, ...raises: [], tags: [RootEffect],
                                     forbids: [].}
proc pop[T](self: var PackedArray[T]): T {.inline.}
proc pop[T](self: var TypedArray[T]): T {.inline.}
proc popAt(self: var Array; position: Int): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}
proc popAt[T](self: var TypedArray[T]; position: Int): T
proc popBack(self: var Array): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}
proc popBack[T](self: var TypedArray[T]): T
proc popFront(self: var Array): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}
proc popFront[T](self: var TypedArray[T]): T
proc pushBack(self: var Array; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedByteArray; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedColorArray; value: Color): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedFloat32Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedFloat64Array; value: Float): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedInt32Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedInt64Array; value: Int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedStringArray; value: String): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedVector2Array; value: Vector2): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedVector3Array; value: Vector3): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack(self: var PackedVector4Array; value: Vector4): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushBack[T](self: var TypedArray[T]; value: T): void
proc pushFront(self: var Array; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc pushFront[T](self: var TypedArray[T]; value: T): void
proc reduce(self: Array; method: Callable; accum: Variant = default(Variant)): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc removeAt(self: var Array; position: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedByteArray; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedColorArray; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedFloat32Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedFloat64Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedInt32Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedInt64Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedStringArray; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedVector2Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedVector3Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc removeAt(self: var PackedVector4Array; index: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var Array; size: Int): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc resize(self: var PackedByteArray; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedColorArray; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedFloat32Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedFloat64Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedInt32Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedInt64Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedStringArray; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedVector2Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedVector3Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc resize(self: var PackedVector4Array; newSize: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var Array): void {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc reverse(self: var PackedByteArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc reverse(self: var PackedColorArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc reverse(self: var PackedFloat32Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var PackedFloat64Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var PackedInt32Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc reverse(self: var PackedInt64Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc reverse(self: var PackedStringArray): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var PackedVector2Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var PackedVector3Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reverse(self: var PackedVector4Array): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rfind(self: Array; what: Variant; from: Int = -1): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rfind(self: PackedByteArray; value: Int; from: Int = -1): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rfind(self: PackedColorArray; value: Color; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedFloat32Array; value: Float; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedFloat64Array; value: Float; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedInt32Array; value: Int; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedInt64Array; value: Int; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedStringArray; value: String; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedVector2Array; value: Vector2; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedVector3Array; value: Vector3; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind(self: PackedVector4Array; value: Vector4; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rfind[T](self: TypedArray[T]; what: T; from: Int = -1): Int
proc rfindCustom(self: Array; method: Callable; from: Int = -1): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var Array; index: Int; value: Variant): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc set(self: var PackedByteArray; index: Int; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc set(self: var PackedColorArray; index: Int; value: Color): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedFloat32Array; index: Int; value: Float): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedFloat64Array; index: Int; value: Float): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedInt32Array; index: Int; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc set(self: var PackedInt64Array; index: Int; value: Int): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc set(self: var PackedStringArray; index: Int; value: String): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedVector2Array; index: Int; value: Vector2): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedVector3Array; index: Int; value: Vector3): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set(self: var PackedVector4Array; index: Int; value: Vector4): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc set[T](self: var TypedArray[T]; index: Int; value: T): void
proc setLen(arr: var Array; newlen: int) {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
proc setLen(arr: var PackedArray; newlen: int) {.inline.}
proc shuffle(self: var Array): void {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc size(self: Array): Int {....raises: [], tags: [RootEffect], forbids: [].}
proc size(self: PackedByteArray): Int {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc size(self: PackedColorArray): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedFloat32Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedFloat64Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedInt32Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedInt64Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedStringArray): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedVector2Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedVector3Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc size(self: PackedVector4Array): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc slice(self: Array; begin: Int; end: Int = 2147483647; step: Int = 1;
           deep: bool = false): Array {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc slice(self: PackedByteArray; begin: Int; end: Int = 2147483647): PackedByteArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedColorArray; begin: Int; end: Int = 2147483647): PackedColorArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedFloat32Array; begin: Int; end: Int = 2147483647): PackedFloat32Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedFloat64Array; begin: Int; end: Int = 2147483647): PackedFloat64Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedInt32Array; begin: Int; end: Int = 2147483647): PackedInt32Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedInt64Array; begin: Int; end: Int = 2147483647): PackedInt64Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedStringArray; begin: Int; end: Int = 2147483647): PackedStringArray {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedVector2Array; begin: Int; end: Int = 2147483647): PackedVector2Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedVector3Array; begin: Int; end: Int = 2147483647): PackedVector3Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice(self: PackedVector4Array; begin: Int; end: Int = 2147483647): PackedVector4Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slice[T](self: TypedArray[T]; begin: Int; end: Int = 2147483647;
              step: Int = 1; deep: bool = false): TypedArray[T]
proc sort(self: var Array): void {....raises: [], tags: [RootEffect], forbids: [].}
proc sort(self: var PackedByteArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedColorArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedFloat32Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedFloat64Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedInt32Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedInt64Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedStringArray): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedVector2Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedVector3Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sort(self: var PackedVector4Array): void {....raises: [], tags: [RootEffect],
    forbids: [].}
proc sortCustom(self: var Array; func: Callable): void {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedColorArray): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedFloat32Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedFloat64Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedInt32Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedInt64Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedStringArray): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedVector2Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedVector3Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toByteArray(self: PackedVector4Array): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toFloat32Array(self: PackedByteArray): PackedFloat32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toFloat64Array(self: PackedByteArray): PackedFloat64Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toInt32Array(self: PackedByteArray): PackedInt32Array {....raises: [],
    tags: [RootEffect], forbids: [].}
proc toInt64Array(self: PackedByteArray): PackedInt64Array {....raises: [],
    tags: [RootEffect], forbids: [].}

Iterators

iterator items(arr: Array): Variant {....raises: [], tags: [RootEffect],
                                      forbids: [].}
iterator items[T](arr: PackedArray[T]): T
iterator items[T](arr: TypedArray[T]): T
iterator mitems(arr: var Array): var Variant {....raises: [], tags: [RootEffect],
    forbids: [].}
iterator mitems[T](arr: var PackedArray[T]): var T
iterator mitems[T](arr: var TypedArray[T]): var T
iterator mpairs(arr: var Array): (int, var Variant) {....raises: [],
    tags: [RootEffect], forbids: [].}
iterator mpairs[T](arr: var PackedArray[T]): (int, var T)
iterator mpairs[T](arr: var TypedArray[T]): (int, var T)
iterator pairs(arr: Array): (int, Variant) {....raises: [], tags: [RootEffect],
    forbids: [].}
iterator pairs[T](arr: PackedArray[T]): (int, T)
iterator pairs[T](arr: TypedArray[T]): (int, T)

Templates

template gdArray(args: varargs[untyped]): untyped {.
    ...deprecated: "use newArray instead".}
Deprecated: use newArray instead 
template packedByteArray(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedByteArray instead".}
Deprecated: use newPackedByteArray instead 
template packedColorArray(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedColorArray instead".}
Deprecated: use newPackedColorArray instead 
template packedFloat32Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedFloat32Array instead".}
Deprecated: use newPackedFloat32Array instead 
template packedFloat64Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedFloat64Array instead".}
Deprecated: use newPackedFloat64Array instead 
template packedInt32Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedInt32Array instead".}
Deprecated: use newPackedInt32Array instead 
template packedInt64Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedInt64Array instead".}
Deprecated: use newPackedInt64Array instead 
template packedStringArray(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedStringArray instead".}
Deprecated: use newPackedStringArray instead 
template packedVector2Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedVector2Array instead".}
Deprecated: use newPackedVector2Array instead 
template packedVector3Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedVector3Array instead".}
Deprecated: use newPackedVector3Array instead 
template packedVector4Array(args: varargs[untyped]): untyped {.
    ...deprecated: "use newPackedVector4Array instead".}
Deprecated: use newPackedVector4Array instead 
template toOpenArray(arr: Array): openArray[Variant]
template toOpenArray[T](arr: PackedArray[T]): openArray[T]
template toSeq[T](arr: PackedArray[T]): seq[T] {....deprecated: "use `@` instead".}
Deprecated: use `@` instead 
template typedArray[T](): TypedArray[T] {.
    ...deprecated: "use newTypedArray instead".}
Deprecated: use newTypedArray instead 
template typedArray[T](arr: Array): TypedArray[T] {.
    ...deprecated: "use newTypedArray instead".}
Deprecated: use newTypedArray instead 
template typedArray[T](len: Natural): TypedArray[T] {.
    ...deprecated: "use newTypedArray instead".}
Deprecated: use newTypedArray instead

Made with Nim. Generated: 2025-04-27 02:52:44 UTC