PoolByteArray = ref object
  godotPoolByteArray: GodotPoolByteArray

PoolIntArray = ref object
  godotPoolIntArray: GodotPoolIntArray

PoolRealArray = ref object
  godotPoolRealArray: GodotPoolRealArray

PoolVector2Array = ref object
  godotPoolVector2Array: GodotPoolVector2Array

PoolVector3Array = ref object
  godotPoolVector3Array: GodotPoolVector3Array

PoolColorArray = ref object
  godotPoolColorArray: GodotPoolColorArray

PoolStringArray = ref object
  godotPoolStringArray: GodotPoolStringArray

proc newPoolByteArray(): PoolByteArray {.
inline, raises: [Exception],
                                      tags: [RootEffect]
.}

proc godotPoolByteArray(self125086: PoolByteArray): ptr GodotPoolByteArray {.
inline,
    raises: [], tags: []
.}

proc newPoolByteArray(arr125088: GodotPoolByteArray): PoolByteArray {.
inline,
    raises: [Exception], tags: [RootEffect]
.}

proc newPoolIntArray(): PoolIntArray {.
inline, raises: [Exception], tags: [RootEffect]
.}

proc godotPoolIntArray(self125147: PoolIntArray): ptr GodotPoolIntArray {.
inline,
    raises: [], tags: []
.}

proc newPoolIntArray(arr125149: GodotPoolIntArray): PoolIntArray {.
inline,
    raises: [Exception], tags: [RootEffect]
.}

proc newPoolRealArray(): PoolRealArray {.
inline, raises: [Exception],
                                      tags: [RootEffect]
.}

proc godotPoolRealArray(self125210: PoolRealArray): ptr GodotPoolRealArray {.
inline,
    raises: [], tags: []
.}

proc newPoolRealArray(arr125212: GodotPoolRealArray): PoolRealArray {.
inline,
    raises: [Exception], tags: [RootEffect]
.}

proc newPoolVector2Array(): PoolVector2Array {.
inline, raises: [Exception],
    tags: [RootEffect]
.}

proc godotPoolVector2Array(self125273: PoolVector2Array): ptr GodotPoolVector2Array {.

    inline, raises: [], tags: []
.}

proc newPoolVector2Array(arr125275: GodotPoolVector2Array): PoolVector2Array {.

    inline, raises: [Exception], tags: [RootEffect]
.}

proc newPoolVector3Array(): PoolVector3Array {.
inline, raises: [Exception],
    tags: [RootEffect]
.}

proc godotPoolVector3Array(self125336: PoolVector3Array): ptr GodotPoolVector3Array {.

    inline, raises: [], tags: []
.}

proc newPoolVector3Array(arr125338: GodotPoolVector3Array): PoolVector3Array {.

    inline, raises: [Exception], tags: [RootEffect]
.}

proc newPoolColorArray(): PoolColorArray {.
inline, raises: [Exception],
                                        tags: [RootEffect]
.}

proc godotPoolColorArray(self125399: PoolColorArray): ptr GodotPoolColorArray {.

    inline, raises: [], tags: []
.}

proc newPoolColorArray(arr125401: GodotPoolColorArray): PoolColorArray {.
inline,
    raises: [Exception], tags: [RootEffect]
.}

proc newPoolStringArray(): PoolStringArray {.
inline, raises: [Exception],
    tags: [RootEffect]
.}

proc godotPoolStringArray(self125462: PoolStringArray): ptr GodotPoolStringArray {.

    inline, raises: [], tags: []
.}

proc newPoolStringArray(arr125464: GodotPoolStringArray): PoolStringArray {.
inline,
    raises: [Exception], tags: [RootEffect]
.}

proc newPoolByteArray(arr170002: Array): PoolByteArray {.
inline, raises: [], tags: []
.}

proc add(self170004: PoolByteArray; arr170006: PoolByteArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self170008: PoolByteArray; idx170010: int) {.
inline, raises: [], tags: []
.}

proc reverse(self170012: PoolByteArray) {.
inline, raises: [], tags: []
.}

proc setLen(self170014: PoolByteArray; size170016: int) {.
inline, raises: [], tags: []
.}

proc len(self170018: PoolByteArray): int {.
inline, raises: [], tags: []
.}

proc add(self170020: PoolByteArray; data170022: uint8) {.
inline, raises: [], tags: []
.}

proc insert(self170024: PoolByteArray; idx170026: int; data170028: uint8): Error {.

    inline, raises: [], tags: []
.}

proc `[]=`(self170030: PoolByteArray; idx170032: int; data170034: uint8) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self170036: PoolByteArray; idx170038: int): uint8 {.
inline, raises: [],
    tags: []
.}

proc newPoolIntArray(arr170202: Array): PoolIntArray {.
inline, raises: [], tags: []
.}

proc add(self170204: PoolIntArray; arr170206: PoolIntArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self170208: PoolIntArray; idx170210: int) {.
inline, raises: [], tags: []
.}

proc reverse(self170212: PoolIntArray) {.
inline, raises: [], tags: []
.}

proc setLen(self170214: PoolIntArray; size170216: int) {.
inline, raises: [], tags: []
.}

proc len(self170218: PoolIntArray): int {.
inline, raises: [], tags: []
.}

proc add(self170220: PoolIntArray; data170222: cint) {.
inline, raises: [], tags: []
.}

proc insert(self170224: PoolIntArray; idx170226: int; data170228: cint): Error {.
inline,
    raises: [], tags: []
.}

proc `[]=`(self170230: PoolIntArray; idx170232: int; data170234: cint) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self170236: PoolIntArray; idx170238: int): cint {.
inline, raises: [], tags: []
.}

proc newPoolRealArray(arr170402: Array): PoolRealArray {.
inline, raises: [], tags: []
.}

proc add(self170404: PoolRealArray; arr170406: PoolRealArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self170408: PoolRealArray; idx170410: int) {.
inline, raises: [], tags: []
.}

proc reverse(self170412: PoolRealArray) {.
inline, raises: [], tags: []
.}

proc setLen(self170414: PoolRealArray; size170416: int) {.
inline, raises: [], tags: []
.}

proc len(self170418: PoolRealArray): int {.
inline, raises: [], tags: []
.}

proc add(self170420: PoolRealArray; data170422: float64) {.
inline, raises: [], tags: []
.}

proc insert(self170424: PoolRealArray; idx170426: int; data170428: float64): Error {.

    inline, raises: [], tags: []
.}

proc `[]=`(self170430: PoolRealArray; idx170432: int; data170434: float64) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self170436: PoolRealArray; idx170438: int): float64 {.
inline, raises: [],
    tags: []
.}

proc newPoolVector2Array(arr170602: Array): PoolVector2Array {.
inline, raises: [],
    tags: []
.}

proc add(self170604: PoolVector2Array; arr170606: PoolVector2Array) {.
inline,
    raises: [], tags: []
.}

proc delete(self170608: PoolVector2Array; idx170610: int) {.
inline, raises: [], tags: []
.}

proc reverse(self170612: PoolVector2Array) {.
inline, raises: [], tags: []
.}

proc setLen(self170614: PoolVector2Array; size170616: int) {.
inline, raises: [],
    tags: []
.}

proc len(self170618: PoolVector2Array): int {.
inline, raises: [], tags: []
.}

proc add(self170620: PoolVector2Array; data170622: Vector2) {.
inline, raises: [],
    tags: []
.}

proc insert(self170624: PoolVector2Array; idx170626: int; data170628: Vector2): Error {.

    inline, raises: [], tags: []
.}

proc `[]=`(self170630: PoolVector2Array; idx170632: int; data170634: Vector2) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self170636: PoolVector2Array; idx170638: int): Vector2 {.
inline, raises: [],
    tags: []
.}

proc newPoolVector3Array(arr170802: Array): PoolVector3Array {.
inline, raises: [],
    tags: []
.}

proc add(self170804: PoolVector3Array; arr170806: PoolVector3Array) {.
inline,
    raises: [], tags: []
.}

proc delete(self170808: PoolVector3Array; idx170810: int) {.
inline, raises: [], tags: []
.}

proc reverse(self170812: PoolVector3Array) {.
inline, raises: [], tags: []
.}

proc setLen(self170814: PoolVector3Array; size170816: int) {.
inline, raises: [],
    tags: []
.}

proc len(self170818: PoolVector3Array): int {.
inline, raises: [], tags: []
.}

proc add(self170820: PoolVector3Array; data170822: Vector3) {.
inline, raises: [],
    tags: []
.}

proc insert(self170824: PoolVector3Array; idx170826: int; data170828: Vector3): Error {.

    inline, raises: [], tags: []
.}

proc `[]=`(self170830: PoolVector3Array; idx170832: int; data170834: Vector3) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self170836: PoolVector3Array; idx170838: int): Vector3 {.
inline, raises: [],
    tags: []
.}

proc newPoolColorArray(arr171002: Array): PoolColorArray {.
inline, raises: [], tags: []
.}

proc add(self171004: PoolColorArray; arr171006: PoolColorArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self171008: PoolColorArray; idx171010: int) {.
inline, raises: [], tags: []
.}

proc reverse(self171012: PoolColorArray) {.
inline, raises: [], tags: []
.}

proc setLen(self171014: PoolColorArray; size171016: int) {.
inline, raises: [], tags: []
.}

proc len(self171018: PoolColorArray): int {.
inline, raises: [], tags: []
.}

proc add(self171020: PoolColorArray; data171022: Color) {.
inline, raises: [], tags: []
.}

proc insert(self171024: PoolColorArray; idx171026: int; data171028: Color): Error {.

    inline, raises: [], tags: []
.}

proc `[]=`(self171030: PoolColorArray; idx171032: int; data171034: Color) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self171036: PoolColorArray; idx171038: int): Color {.
inline, raises: [],
    tags: []
.}

proc newPoolStringArray(arr171202: Array): PoolStringArray {.
inline, raises: [],
    tags: []
.}

proc add(self171204: PoolStringArray; arr171206: PoolStringArray) {.
inline,
    raises: [], tags: []
.}

proc delete(self171208: PoolStringArray; idx171210: int) {.
inline, raises: [], tags: []
.}

proc reverse(self171212: PoolStringArray) {.
inline, raises: [], tags: []
.}

proc setLen(self171214: PoolStringArray; size171216: int) {.
inline, raises: [], tags: []
.}

proc len(self171218: PoolStringArray): int {.
inline, raises: [], tags: []
.}

proc add(self: PoolStringArray; data: string) {.
raises: [], tags: []
.}

proc insert(self: PoolStringArray; idx: int; data: string): Error {.
raises: [], tags: []
.}

proc `[]=`(self: PoolStringArray; idx: int; data: string) {.
raises: [], tags: []
.}

proc `[]`(self: PoolStringArray; idx: int): string {.
raises: [], tags: []
.}

iterator items(arr170040: PoolByteArray): uint8 {.
raises: [], tags: []
.}

iterator pairs(arr170044: PoolByteArray): tuple[key: int, val: uint8] {.
raises: [],
    tags: []
.}

iterator items(arr170240: PoolIntArray): cint {.
raises: [], tags: []
.}

iterator pairs(arr170244: PoolIntArray): tuple[key: int, val: cint] {.
raises: [],
    tags: []
.}

iterator items(arr170440: PoolRealArray): float64 {.
raises: [], tags: []
.}

iterator pairs(arr170444: PoolRealArray): tuple[key: int, val: float64] {.
raises: [],
    tags: []
.}

iterator items(arr170640: PoolVector2Array): Vector2 {.
raises: [], tags: []
.}

iterator pairs(arr170644: PoolVector2Array): tuple[key: int, val: Vector2] {.

    raises: [], tags: []
.}

iterator items(arr170840: PoolVector3Array): Vector3 {.
raises: [], tags: []
.}

iterator pairs(arr170844: PoolVector3Array): tuple[key: int, val: Vector3] {.

    raises: [], tags: []
.}

iterator items(arr171040: PoolColorArray): Color {.
raises: [], tags: []
.}

iterator pairs(arr171044: PoolColorArray): tuple[key: int, val: Color] {.
raises: [],
    tags: []
.}

iterator items(arr: PoolStringArray): string {.
raises: [], tags: []
.}

iterator pairs(arr: PoolStringArray): tuple[key: int, val: string] {.
raises: [], tags: []
.}