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

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

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

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

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

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

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

proc insert(self171024: PoolByteArray; idx171026: int; data171028: uint8): Error {.

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

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

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

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

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

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

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

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

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

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

proc insert(self171224: PoolIntArray; idx171226: int; data171228: cint): Error {.
inline,
    raises: [], tags: []
.}

proc `[]=`(self171230: PoolIntArray; idx171232: int; data171234: cint) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self171424: PoolRealArray; idx171426: int; data171428: float64): Error {.

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

proc `[]=`(self171430: PoolRealArray; idx171432: int; data171434: float64) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self171624: PoolVector2Array; idx171626: int; data171628: Vector2): Error {.

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

proc `[]=`(self171630: PoolVector2Array; idx171632: int; data171634: Vector2) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self171824: PoolVector3Array; idx171826: int; data171828: Vector3): Error {.

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

proc `[]=`(self171830: PoolVector3Array; idx171832: int; data171834: Vector3) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

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

proc insert(self172024: PoolColorArray; idx172026: int; data172028: Color): Error {.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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