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(self126086: PoolByteArray): ptr GodotPoolByteArray {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

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

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

proc newPoolVector2Array(arr126275: GodotPoolVector2Array): PoolVector2Array {.

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

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

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

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

proc newPoolVector3Array(arr126338: GodotPoolVector3Array): PoolVector3Array {.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc insert(self173024: PoolByteArray; idx173026: int; data173028: uint8): Error {.

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

proc `[]=`(self173030: PoolByteArray; idx173032: int; data173034: uint8) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self173224: PoolIntArray; idx173226: int; data173228: cint): Error {.
inline,
    raises: [], tags: []
.}

proc `[]=`(self173230: PoolIntArray; idx173232: int; data173234: cint) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self173424: PoolRealArray; idx173426: int; data173428: float64): Error {.

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

proc `[]=`(self173430: PoolRealArray; idx173432: int; data173434: float64) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self173624: PoolVector2Array; idx173626: int; data173628: Vector2): Error {.

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

proc `[]=`(self173630: PoolVector2Array; idx173632: int; data173634: Vector2) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self173824: PoolVector3Array; idx173826: int; data173828: Vector3): Error {.

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

proc `[]=`(self173830: PoolVector3Array; idx173832: int; data173834: Vector3) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self174024: PoolColorArray; idx174026: int; data174028: Color): Error {.

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

proc `[]=`(self174030: PoolColorArray; idx174032: int; data174034: Color) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

proc len(self174218: 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(arr173040: PoolByteArray): uint8 {.
raises: [], tags: []
.}

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

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

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

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

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

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

iterator pairs(arr174044: 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: []
.}