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

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

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

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

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

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

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

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

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

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

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

proc newPoolVector2Array(arr127275: GodotPoolVector2Array): PoolVector2Array {.

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

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

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

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

proc newPoolVector3Array(arr127338: GodotPoolVector3Array): PoolVector3Array {.

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

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

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

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

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

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

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

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

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

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

proc add(self172004: var PoolByteArray; arr172006: PoolByteArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self172008: var PoolByteArray; idx172010: int) {.
inline, raises: [], tags: []
.}

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

proc setLen(self172014: var PoolByteArray; size172016: int) {.
inline, raises: [],
    tags: []
.}

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

proc add(self172020: var PoolByteArray; data172022: uint8) {.
inline, raises: [], tags: []
.}

proc insert(self172024: var PoolByteArray; idx172026: int; data172028: uint8): Error {.

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

proc `[]=`(self172030: var PoolByteArray; idx172032: int; data172034: uint8) {.
inline,
    raises: [], tags: []
.}

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

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

proc add(self172204: var PoolIntArray; arr172206: PoolIntArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self172208: var PoolIntArray; idx172210: int) {.
inline, raises: [], tags: []
.}

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

proc setLen(self172214: var PoolIntArray; size172216: int) {.
inline, raises: [], tags: []
.}

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

proc add(self172220: var PoolIntArray; data172222: cint) {.
inline, raises: [], tags: []
.}

proc insert(self172224: var PoolIntArray; idx172226: int; data172228: cint): Error {.

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

proc `[]=`(self172230: var PoolIntArray; idx172232: int; data172234: cint) {.
inline,
    raises: [], tags: []
.}

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

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

proc add(self172404: var PoolRealArray; arr172406: PoolRealArray) {.
inline, raises: [],
    tags: []
.}

proc delete(self172408: var PoolRealArray; idx172410: int) {.
inline, raises: [], tags: []
.}

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

proc setLen(self172414: var PoolRealArray; size172416: int) {.
inline, raises: [],
    tags: []
.}

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

proc add(self172420: var PoolRealArray; data172422: float64) {.
inline, raises: [],
    tags: []
.}

proc insert(self172424: var PoolRealArray; idx172426: int; data172428: float64): Error {.

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

proc `[]=`(self172430: var PoolRealArray; idx172432: int; data172434: float64) {.
inline,
    raises: [], tags: []
.}

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

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

proc add(self172604: var PoolVector2Array; arr172606: PoolVector2Array) {.
inline,
    raises: [], tags: []
.}

proc delete(self172608: var PoolVector2Array; idx172610: int) {.
inline, raises: [],
    tags: []
.}

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

proc setLen(self172614: var PoolVector2Array; size172616: int) {.
inline, raises: [],
    tags: []
.}

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

proc add(self172620: var PoolVector2Array; data172622: Vector2) {.
inline, raises: [],
    tags: []
.}

proc insert(self172624: var PoolVector2Array; idx172626: int; data172628: Vector2): Error {.

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

proc `[]=`(self172630: var PoolVector2Array; idx172632: int; data172634: Vector2) {.

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

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

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

proc add(self172804: var PoolVector3Array; arr172806: PoolVector3Array) {.
inline,
    raises: [], tags: []
.}

proc delete(self172808: var PoolVector3Array; idx172810: int) {.
inline, raises: [],
    tags: []
.}

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

proc setLen(self172814: var PoolVector3Array; size172816: int) {.
inline, raises: [],
    tags: []
.}

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

proc add(self172820: var PoolVector3Array; data172822: Vector3) {.
inline, raises: [],
    tags: []
.}

proc insert(self172824: var PoolVector3Array; idx172826: int; data172828: Vector3): Error {.

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

proc `[]=`(self172830: var PoolVector3Array; idx172832: int; data172834: Vector3) {.

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

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

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

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

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

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

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

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

proc add(self173020: var PoolColorArray; data173022: Color) {.
inline, raises: [],
    tags: []
.}

proc insert(self173024: var PoolColorArray; idx173026: int; data173028: Color): Error {.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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