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.

PackedArray

A primitive dynamic array provided by Godot.

Procs

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

Iterators

iterator items[T](arr: Array[T]): T
iterator items[T](arr: PackedArray[T]): T
iterator mitems[T: SomeBuiltins or Variant](arr: var Array[T]): var T
iterator mitems[T](arr: var PackedArray[T]): var T
iterator mpairs[T: SomeBuiltins or Variant](arr: var Array[T]): (int, var T)
iterator mpairs[T](arr: var PackedArray[T]): (int, var T)
iterator pairs[T](arr: Array[T]): (int, T)
iterator pairs[T](arr: PackedArray[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

Made with Nim. Generated: 2025-11-25 08:34:29 UTC