GodotPoolByteArray* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolIntArray* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolRealArray* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolStringArray* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolVector2Array* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolVector3Array* {.
byref
.} = object
  data: array[sizeof(int), byte]

GodotPoolColorArray* {.
byref
.} = object
  data: array[sizeof(int), byte]

proc initGodotPoolByteArray*(dest: var GodotPoolByteArray) {.

    importc: "godot_pool_byte_array_new"
.}

proc initGodotPoolByteArray*(dest: var GodotPoolByteArray; src: GodotPoolByteArray) {.

    importc: "godot_pool_byte_array_new_copy"
.}

proc initGodotPoolByteArray*(dest: var GodotPoolByteArray; arr: GodotArray) {.

    importc: "godot_pool_byte_array_new_with_array"
.}

proc deinit*(self: var GodotPoolByteArray) {.

    importc: "godot_pool_byte_array_destroy"
.}

proc add*(self: var GodotPoolByteArray; data: uint8) {.

    importc: "godot_pool_byte_array_append"
.}

proc addFirst*(self: var GodotPoolByteArray; data: uint8) {.

    importc: "godot_pool_byte_array_push_back"
.}

proc add*(self: var GodotPoolByteArray; arr: GodotPoolByteArray) {.

    importc: "godot_pool_byte_array_append_array"
.}

proc insert*(self: var GodotPoolByteArray; idx: cint; data: uint8): Error {.

    importc: "godot_pool_byte_array_insert"
.}

proc delete*(self: var GodotPoolByteArray; idx: cint) {.

    importc: "godot_pool_byte_array_remove"
.}

proc reverse*(self: var GodotPoolByteArray) {.

    importc: "godot_pool_byte_array_invert"
.}

proc setLen*(self: var GodotPoolByteArray; size: cint) {.

    importc: "godot_pool_byte_array_resize"
.}

proc `[]=`*(self: var GodotPoolByteArray; idx: cint; data: uint8) {.

    importc: "godot_pool_byte_array_set"
.}

proc `[]`*(self: GodotPoolByteArray; idx: cint): uint8 {.
noSideEffect,
    importc: "godot_pool_byte_array_get"
.}

proc len*(self: GodotPoolByteArray): cint {.
noSideEffect,
                                        importc: "godot_pool_byte_array_size"
.}

proc initGodotPoolIntArray*(dest: var GodotPoolIntArray) {.

    importc: "godot_pool_int_array_new"
.}

proc initGodotPoolIntArray*(dest: var GodotPoolIntArray; src: GodotPoolIntArray) {.

    importc: "godot_pool_int_array_new_copy"
.}

proc initGodotPoolIntArray*(dest: var GodotPoolIntArray; arr: GodotArray) {.

    importc: "godot_pool_int_array_new_with_array"
.}

proc deinit*(self: var GodotPoolIntArray) {.
importc: "godot_pool_int_array_destroy"
.}

proc add*(self: var GodotPoolIntArray; data: cint) {.

    importc: "godot_pool_int_array_append"
.}

proc addFirst*(self: var GodotPoolIntArray; data: cint) {.

    importc: "godot_pool_int_array_push_back"
.}

proc add*(self: var GodotPoolIntArray; arr: GodotPoolIntArray) {.

    importc: "godot_pool_int_array_append_array"
.}

proc insert*(self: var GodotPoolIntArray; idx: cint; data: cint): Error {.

    importc: "godot_pool_int_array_insert"
.}

proc delete*(self: var GodotPoolIntArray; idx: cint) {.

    importc: "godot_pool_int_array_remove"
.}

proc reverse*(self: var GodotPoolIntArray) {.
importc: "godot_pool_int_array_invert"
.}

proc setLen*(self: var GodotPoolIntArray; size: cint) {.

    importc: "godot_pool_int_array_resize"
.}

proc `[]=`*(self: var GodotPoolIntArray; idx: cint; data: cint) {.

    importc: "godot_pool_int_array_set"
.}

proc `[]`*(self: GodotPoolIntArray; idx: cint): cint {.
noSideEffect,
    importc: "godot_pool_int_array_get"
.}

proc len*(self: GodotPoolIntArray): cint {.
noSideEffect,
                                       importc: "godot_pool_int_array_size"
.}

proc initGodotPoolRealArray*(dest: var GodotPoolRealArray) {.

    importc: "godot_pool_real_array_new"
.}

proc initGodotPoolRealArray*(dest: var GodotPoolRealArray; src: GodotPoolRealArray) {.

    importc: "godot_pool_real_array_new_copy"
.}

proc initGodotPoolRealArray*(dest: var GodotPoolRealArray; arr: GodotArray) {.

    importc: "godot_pool_real_array_new_with_array"
.}

proc deinit*(self: var GodotPoolRealArray) {.

    importc: "godot_pool_real_array_destroy"
.}

proc add*(self: var GodotPoolRealArray; data: float32) {.

    importc: "godot_pool_real_array_append"
.}

proc addFirst*(self: var GodotPoolRealArray; data: float32) {.

    importc: "godot_pool_real_array_push_back"
.}

proc add*(self: var GodotPoolRealArray; arr: GodotPoolRealArray) {.

    importc: "godot_pool_real_array_append_array"
.}

proc insert*(self: var GodotPoolRealArray; idx: cint; data: float32): Error {.

    importc: "godot_pool_real_array_insert"
.}

proc delete*(self: var GodotPoolRealArray; idx: cint) {.

    importc: "godot_pool_real_array_remove"
.}

proc reverse*(self: var GodotPoolRealArray) {.

    importc: "godot_pool_real_array_invert"
.}

proc setLen*(self: var GodotPoolRealArray; size: cint) {.

    importc: "godot_pool_real_array_resize"
.}

proc `[]=`*(self: var GodotPoolRealArray; idx: cint; data: float32) {.

    importc: "godot_pool_real_array_set"
.}

proc `[]`*(self: GodotPoolRealArray; idx: cint): float32 {.
noSideEffect,
    importc: "godot_pool_real_array_get"
.}

proc len*(self: GodotPoolRealArray): cint {.
noSideEffect,
                                        importc: "godot_pool_real_array_size"
.}

proc initGodotPoolStringArray*(dest: var GodotPoolStringArray) {.

    importc: "godot_pool_string_array_new"
.}

proc initGodotPoolStringArray*(dest: var GodotPoolStringArray;
                              src: GodotPoolStringArray) {.

    importc: "godot_pool_string_array_new_copy"
.}

proc initGodotPoolStringArray*(dest: var GodotPoolStringArray; arr: GodotArray) {.

    importc: "godot_pool_string_array_new_with_array"
.}

proc deinit*(self: var GodotPoolStringArray) {.

    importc: "godot_pool_string_array_destroy"
.}

proc initGodotPoolStringArray*(): GodotPoolStringArray {.
inline
.}

proc initGodotPoolStringArray*(arr: GodotArray): GodotPoolStringArray {.
inline
.}

proc add*(self: var GodotPoolStringArray; data: GodotString) {.

    importc: "godot_pool_string_array_append"
.}

proc addFirst*(self: var GodotPoolStringArray; data: GodotString) {.

    importc: "godot_pool_string_array_push_back"
.}

proc add*(self: var GodotPoolStringArray; arr: GodotPoolStringArray) {.

    importc: "godot_pool_string_array_append_array"
.}

proc insert*(self: var GodotPoolStringArray; idx: cint; data: GodotString): Error {.

    importc: "godot_pool_string_array_insert"
.}

proc delete*(self: var GodotPoolStringArray; idx: cint) {.

    importc: "godot_pool_string_array_remove"
.}

proc reverse*(self: var GodotPoolStringArray) {.

    importc: "godot_pool_string_array_invert"
.}

proc setLen*(self: var GodotPoolStringArray; size: cint) {.

    importc: "godot_pool_string_array_resize"
.}

proc `[]=`*(self: var GodotPoolStringArray; idx: cint; data: GodotString) {.

    importc: "godot_pool_string_array_set"
.}

proc `[]`*(self: GodotPoolStringArray; idx: cint): GodotString {.
noSideEffect,
    importc: "godot_pool_string_array_get"
.}

proc len*(self: GodotPoolStringArray): cint {.
noSideEffect,
    importc: "godot_pool_string_array_size"
.}

proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array) {.

    importc: "godot_pool_vector2_array_new"
.}

proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array;
                               src: GodotPoolVector2Array) {.

    importc: "godot_pool_vector2_array_new_copy"
.}

proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array; arr: GodotArray) {.

    importc: "godot_pool_vector2_array_new_with_array"
.}

proc deinit*(self: var GodotPoolVector2Array) {.

    importc: "godot_pool_vector2_array_destroy"
.}

proc initGodotPoolVector2Array*(): GodotPoolVector2Array {.
inline
.}

proc initGodotPoolVector2Array*(arr: GodotArray): GodotPoolVector2Array {.
inline
.}

proc add*(self: var GodotPoolVector2Array; data: Vector2) {.

    importc: "godot_pool_vector2_array_append"
.}

proc addFirst*(self: var GodotPoolVector2Array; data: Vector2) {.

    importc: "godot_pool_vector2_array_push_back"
.}

proc add*(self: var GodotPoolVector2Array; arr: GodotPoolVector2Array) {.

    importc: "godot_pool_vector2_array_append_array"
.}

proc insert*(self: var GodotPoolVector2Array; idx: cint; data: Vector2): Error {.

    importc: "godot_pool_vector2_array_insert"
.}

proc delete*(self: var GodotPoolVector2Array; idx: cint) {.

    importc: "godot_pool_vector2_array_remove"
.}

proc reverse*(self: var GodotPoolVector2Array) {.

    importc: "godot_pool_vector2_array_invert"
.}

proc setLen*(self: var GodotPoolVector2Array; size: cint) {.

    importc: "godot_pool_vector2_array_resize"
.}

proc `[]=`*(self: var GodotPoolVector2Array; idx: cint; data: Vector2) {.

    importc: "godot_pool_vector2_array_set"
.}

proc `[]`*(self: GodotPoolVector2Array; idx: cint): Vector2 {.
noSideEffect,
    importc: "godot_pool_vector2_array_get"
.}

proc len*(self: GodotPoolVector2Array): cint {.
noSideEffect,
    importc: "godot_pool_vector2_array_size"
.}

proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array) {.

    importc: "godot_pool_vector3_array_new"
.}

proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array;
                               src: GodotPoolVector3Array) {.

    importc: "godot_pool_vector3_array_new_copy"
.}

proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array; arr: GodotArray) {.

    importc: "godot_pool_vector3_array_new_with_array"
.}

proc deinit*(self: var GodotPoolVector3Array) {.

    importc: "godot_pool_vector3_array_destroy"
.}

proc initGodotPoolVector3Array*(): GodotPoolVector3Array {.
inline
.}

proc initGodotPoolVector3Array*(arr: GodotArray): GodotPoolVector3Array {.
inline
.}

proc add*(self: var GodotPoolVector3Array; data: Vector3) {.

    importc: "godot_pool_vector3_array_append"
.}

proc addFirst*(self: var GodotPoolVector3Array; data: Vector3) {.

    importc: "godot_pool_vector3_array_push_back"
.}

proc add*(self: var GodotPoolVector3Array; arr: GodotPoolVector3Array) {.

    importc: "godot_pool_vector3_array_append_array"
.}

proc insert*(self: var GodotPoolVector3Array; idx: cint; data: Vector3): Error {.

    importc: "godot_pool_vector3_array_insert"
.}

proc delete*(self: var GodotPoolVector3Array; idx: cint) {.

    importc: "godot_pool_vector3_array_remove"
.}

proc reverse*(self: var GodotPoolVector3Array) {.

    importc: "godot_pool_vector3_array_invert"
.}

proc setLen*(self: var GodotPoolVector3Array; size: cint) {.

    importc: "godot_pool_vector3_array_resize"
.}

proc `[]=`*(self: var GodotPoolVector3Array; idx: cint; data: Vector3) {.

    importc: "godot_pool_vector3_array_set"
.}

proc `[]`*(self: GodotPoolVector3Array; idx: cint): Vector3 {.
noSideEffect,
    importc: "godot_pool_vector3_array_get"
.}

proc len*(self: GodotPoolVector3Array): cint {.
noSideEffect,
    importc: "godot_pool_vector3_array_size"
.}

proc initGodotPoolColorArray*(dest: var GodotPoolColorArray) {.

    importc: "godot_pool_color_array_new"
.}

proc initGodotPoolColorArray*(dest: var GodotPoolColorArray;
                             src: GodotPoolColorArray) {.

    importc: "godot_pool_color_array_new_copy"
.}

proc initGodotPoolColorArray*(dest: var GodotPoolColorArray; arr: GodotArray) {.

    importc: "godot_pool_color_array_new_with_array"
.}

proc deinit*(self: var GodotPoolColorArray) {.

    importc: "godot_pool_color_array_destroy"
.}

proc initGodotPoolColorArray*(): GodotPoolColorArray {.
inline
.}

proc initGodotPoolColorArray*(arr: GodotArray): GodotPoolColorArray {.
inline
.}

proc add*(self: var GodotPoolColorArray; data: Color) {.

    importc: "godot_pool_color_array_append"
.}

proc addFirst*(self: var GodotPoolColorArray; data: Color) {.

    importc: "godot_pool_color_array_push_back"
.}

proc add*(self: var GodotPoolColorArray; arr: GodotPoolColorArray) {.

    importc: "godot_pool_color_array_append_array"
.}

proc insert*(self: var GodotPoolColorArray; idx: cint; data: Color): Error {.

    importc: "godot_pool_color_array_insert"
.}

proc delete*(self: var GodotPoolColorArray; idx: cint) {.

    importc: "godot_pool_color_array_remove"
.}

proc reverse*(self: var GodotPoolColorArray) {.

    importc: "godot_pool_color_array_invert"
.}

proc setLen*(self: var GodotPoolColorArray; size: cint) {.

    importc: "godot_pool_color_array_resize"
.}

proc `[]=`*(self: var GodotPoolColorArray; idx: cint; data: Color) {.

    importc: "godot_pool_color_array_set"
.}

proc `[]`*(self: GodotPoolColorArray; idx: cint): Color {.
noSideEffect,
    importc: "godot_pool_color_array_get"
.}

proc len*(self: GodotPoolColorArray): cint {.
noSideEffect,
    importc: "godot_pool_color_array_size"
.}

iterator items*(arr: GodotPoolByteArray): byte

iterator pairs*(arr: GodotPoolByteArray): tuple[key: cint, val: byte]

iterator items*(arr: GodotPoolIntArray): cint

iterator pairs*(arr: GodotPoolIntArray): tuple[key: cint, val: cint]

iterator items*(arr: GodotPoolRealArray): float32

iterator pairs*(arr: GodotPoolRealArray): tuple[key: cint, val: float32]

iterator items*(arr: GodotPoolStringArray): GodotString

iterator pairs*(arr: GodotPoolStringArray): tuple[key: cint, val: GodotString]

iterator items*(arr: GodotPoolVector2Array): Vector2

iterator pairs*(arr: GodotPoolVector2Array): tuple[key: cint, val: Vector2]

iterator items*(arr: GodotPoolVector3Array): Vector3

iterator pairs*(arr: GodotPoolVector3Array): tuple[key: cint, val: Vector3]

iterator items*(arr: GodotPoolColorArray): Color

iterator pairs*(arr: GodotPoolColorArray): tuple[key: cint, val: Color]