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

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

proc hash(arr178140: PoolByteArray): Hash {.
raises: [], tags: []
.}

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

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

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

proc hash(arr178474: PoolIntArray): Hash {.
raises: [], tags: []
.}

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

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

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

proc hash(arr178654: PoolRealArray): Hash {.
raises: [], tags: []
.}

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

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

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

proc newPoolVector2Array(arr178846: GodotPoolVector2Array): PoolVector2Array {.

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

proc hash(arr178848: PoolVector2Array): Hash {.
raises: [], tags: []
.}

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

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

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

proc newPoolVector3Array(arr179046: GodotPoolVector3Array): PoolVector3Array {.

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

proc hash(arr179048: PoolVector3Array): Hash {.
raises: [], tags: []
.}

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

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

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

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

proc hash(arr179248: PoolColorArray): Hash {.
raises: [], tags: []
.}

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

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

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

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

proc hash(arr179448: PoolStringArray): Hash {.
raises: [], tags: []
.}

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

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

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

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

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

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

proc subarray(self200033: PoolByteArray; idxFrom200035, idxTo200037: int): PoolByteArray {.

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

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

proc insert(self200043: PoolByteArray; idx200045: int; data200047: uint8): Error {.

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

proc `[]=`(self200049: PoolByteArray; idx200051: int; data200053: uint8) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self200833: PoolIntArray; idxFrom200835, idxTo200837: int): PoolIntArray {.

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

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

proc insert(self200843: PoolIntArray; idx200845: int; data200847: cint): Error {.
inline,
    raises: [], tags: []
.}

proc `[]=`(self200849: PoolIntArray; idx200851: int; data200853: cint) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self201633: PoolRealArray; idxFrom201635, idxTo201637: int): PoolRealArray {.

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

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

proc insert(self201643: PoolRealArray; idx201645: int; data201647: float32): Error {.

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

proc `[]=`(self201649: PoolRealArray; idx201651: int; data201653: float32) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self202433: PoolVector2Array; idxFrom202435, idxTo202437: int): PoolVector2Array {.

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

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

proc insert(self202443: PoolVector2Array; idx202445: int; data202447: Vector2): Error {.

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

proc `[]=`(self202449: PoolVector2Array; idx202451: int; data202453: Vector2) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self203233: PoolVector3Array; idxFrom203235, idxTo203237: int): PoolVector3Array {.

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

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

proc insert(self203243: PoolVector3Array; idx203245: int; data203247: Vector3): Error {.

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

proc `[]=`(self203249: PoolVector3Array; idx203251: int; data203253: Vector3) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self204033: PoolColorArray; idxFrom204035, idxTo204037: int): PoolColorArray {.

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

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

proc insert(self204043: PoolColorArray; idx204045: int; data204047: Color): Error {.

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

proc `[]=`(self204049: PoolColorArray; idx204051: int; data204053: Color) {.
inline,
    raises: [], tags: []
.}

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

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

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

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

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

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

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

proc subarray(self204833: PoolStringArray; idxFrom204835, idxTo204837: 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(arr200059: PoolByteArray): uint8 {.
raises: [], tags: []
.}

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

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

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

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

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

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

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

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

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

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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

    raises: [], tags: []
.}

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

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

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

iterator mpairs(arr204071: 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: []
.}