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

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

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

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

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

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

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

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

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

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

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

proc newPoolVector2Array(arr130304: GodotPoolVector2Array): PoolVector2Array {.

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

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

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

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

proc newPoolVector3Array(arr130367: GodotPoolVector3Array): PoolVector3Array {.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc subarray(self177020: PoolByteArray; idxFrom177022, idxTo177024: int): PoolByteArray {.

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

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

proc insert(self177030: PoolByteArray; idx177032: int; data177034: uint8): Error {.

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

proc `[]=`(self177036: PoolByteArray; idx177038: int; data177040: uint8) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self177420: PoolIntArray; idxFrom177422, idxTo177424: int): PoolIntArray {.

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

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

proc insert(self177430: PoolIntArray; idx177432: int; data177434: cint): Error {.
inline,
    raises: [], tags: []
.}

proc `[]=`(self177436: PoolIntArray; idx177438: int; data177440: cint) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self177820: PoolRealArray; idxFrom177822, idxTo177824: int): PoolRealArray {.

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

proc add(self177826: PoolRealArray; data177828: float32) {.
inline, raises: [], tags: []
.}

proc insert(self177830: PoolRealArray; idx177832: int; data177834: float32): Error {.

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

proc `[]=`(self177836: PoolRealArray; idx177838: int; data177840: float32) {.
inline,
    raises: [], tags: []
.}

proc `[]`(self177842: PoolRealArray; idx177844: int): float32 {.
inline, raises: [],
    tags: []
.}

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

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

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

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

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

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

proc subarray(self178220: PoolVector2Array; idxFrom178222, idxTo178224: int): PoolVector2Array {.

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

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

proc insert(self178230: PoolVector2Array; idx178232: int; data178234: Vector2): Error {.

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

proc `[]=`(self178236: PoolVector2Array; idx178238: int; data178240: Vector2) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self178620: PoolVector3Array; idxFrom178622, idxTo178624: int): PoolVector3Array {.

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

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

proc insert(self178630: PoolVector3Array; idx178632: int; data178634: Vector3): Error {.

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

proc `[]=`(self178636: PoolVector3Array; idx178638: int; data178640: Vector3) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self179020: PoolColorArray; idxFrom179022, idxTo179024: int): PoolColorArray {.

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

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

proc insert(self179030: PoolColorArray; idx179032: int; data179034: Color): Error {.

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

proc `[]=`(self179036: PoolColorArray; idx179038: int; data179040: Color) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self179420: PoolStringArray; idxFrom179422, idxTo179424: int): PoolStringArray {.

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

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

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

iterator mitems(arr177054: PoolByteArray): var uint8 {.
raises: [], tags: []
.}

iterator mpairs(arr177058: PoolByteArray): tuple[key: int, val: var uint8] {.
raises: [],
    tags: []
.}

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

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

iterator mitems(arr177454: PoolIntArray): var cint {.
raises: [], tags: []
.}

iterator mpairs(arr177458: PoolIntArray): tuple[key: int, val: var cint] {.
raises: [],
    tags: []
.}

iterator items(arr177846: PoolRealArray): float32 {.
raises: [], tags: []
.}

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

iterator mitems(arr177854: PoolRealArray): var float32 {.
raises: [], tags: []
.}

iterator mpairs(arr177858: PoolRealArray): tuple[key: int, val: var float32] {.

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

iterator mitems(arr178254: PoolVector2Array): var Vector2 {.
raises: [], tags: []
.}

iterator mpairs(arr178258: PoolVector2Array): tuple[key: int, val: var Vector2] {.

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

iterator mitems(arr178654: PoolVector3Array): var Vector3 {.
raises: [], tags: []
.}

iterator mpairs(arr178658: PoolVector3Array): tuple[key: int, val: var Vector3] {.

    raises: [], tags: []
.}

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

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

iterator mitems(arr179054: PoolColorArray): var Color {.
raises: [], tags: []
.}

iterator mpairs(arr179058: PoolColorArray): tuple[key: int, val: var Color] {.

    raises: [], tags: []
.}

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

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