flatbuffers/tests/monster_test_generated.lobster

// automatically generated by the FlatBuffers compiler, do not modify
import flatbuffers

namespace MyGame.Example

/// Composite components of Monster color.
enum Color:
    Color_Red = 1
    /// \brief color Green
    /// Green is bit_flag with value (1u << 1)
    Color_Green = 2
    /// \brief color Blue (1u << 3)
    Color_Blue = 8

enum Race:
    Race_None = -1
    Race_Human = 0
    Race_Dwarf = 1
    Race_Elf = 2

enum LongEnum:
    LongEnum_LongOne = 2
    LongEnum_LongTwo = 4
    LongEnum_LongBig = 1099511627776

enum Any:
    Any_NONE = 0
    Any_Monster = 1
    Any_TestSimpleTableWithEnum = 2
    Any_MyGame_Example2_Monster = 3

enum AnyUniqueAliases:
    AnyUniqueAliases_NONE = 0
    AnyUniqueAliases_M = 1
    AnyUniqueAliases_TS = 2
    AnyUniqueAliases_M2 = 3

enum AnyAmbiguousAliases:
    AnyAmbiguousAliases_NONE = 0
    AnyAmbiguousAliases_M1 = 1
    AnyAmbiguousAliases_M2 = 2
    AnyAmbiguousAliases_M3 = 3

namespace MyGame

class InParentNamespace

namespace MyGame.Example2

class Monster

namespace MyGame.Example

class Test

class TestSimpleTableWithEnum

class Vec3

class Ability

class StructOfStructs

class StructOfStructsOfStructs

class Stat

class Referrable

class Monster

class TypeAliases

namespace MyGame

class InParentNamespace : flatbuffers.handle

def GetRootAsInParentNamespace(buf:string): return InParentNamespace { buf, flatbuffers.indirect(buf, 0) }

struct InParentNamespaceBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(0)
        return this
    def end():
        return b_.EndObject()

namespace MyGame.Example2

class Monster : flatbuffers.handle

def GetRootAsMonster(buf:string): return Monster { buf, flatbuffers.indirect(buf, 0) }

struct MonsterBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(0)
        return this
    def end():
        return b_.EndObject()

namespace MyGame.Example

class Test : flatbuffers.handle
    def a() -> int:
        return buf_.read_int16_le(pos_ + 0)
    def b() -> int:
        return buf_.read_int8_le(pos_ + 2)

def CreateTest(b_:flatbuffers.builder, a:int, b:int):
    b_.Prep(2, 4)
    b_.Pad(1)
    b_.PrependInt8(b)
    b_.PrependInt16(a)
    return b_.Offset()

class TestSimpleTableWithEnum : flatbuffers.handle
    def color() -> Color:
        return Color(flatbuffers.field_uint8(buf_, pos_, 4, 2))

def GetRootAsTestSimpleTableWithEnum(buf:string): return TestSimpleTableWithEnum { buf, flatbuffers.indirect(buf, 0) }

struct TestSimpleTableWithEnumBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(1)
        return this
    def add_color(color:Color):
        b_.PrependUint8Slot(0, color, 2)
        return this
    def end():
        return b_.EndObject()

class Vec3 : flatbuffers.handle
    def x() -> float:
        return buf_.read_float32_le(pos_ + 0)
    def y() -> float:
        return buf_.read_float32_le(pos_ + 4)
    def z() -> float:
        return buf_.read_float32_le(pos_ + 8)
    def test1() -> float:
        return buf_.read_float64_le(pos_ + 16)
    def test2() -> Color:
        return Color(buf_.read_uint8_le(pos_ + 24))
    def test3() -> MyGame.Example.Test:
        return MyGame.Example.Test{ buf_, pos_ + 26 }

def CreateVec3(b_:flatbuffers.builder, x:float, y:float, z:float, test1:float, test2:Color, test3_a:int, test3_b:int):
    b_.Prep(8, 32)
    b_.Pad(2)
    b_.Prep(2, 4)
    b_.Pad(1)
    b_.PrependInt8(test3_b)
    b_.PrependInt16(test3_a)
    b_.Pad(1)
    b_.PrependUint8(test2)
    b_.PrependFloat64(test1)
    b_.Pad(4)
    b_.PrependFloat32(z)
    b_.PrependFloat32(y)
    b_.PrependFloat32(x)
    return b_.Offset()

class Ability : flatbuffers.handle
    def id() -> int:
        return buf_.read_uint32_le(pos_ + 0)
    def distance() -> int:
        return buf_.read_uint32_le(pos_ + 4)

def CreateAbility(b_:flatbuffers.builder, id:int, distance:int):
    b_.Prep(4, 8)
    b_.PrependUint32(distance)
    b_.PrependUint32(id)
    return b_.Offset()

class StructOfStructs : flatbuffers.handle
    def a() -> MyGame.Example.Ability:
        return MyGame.Example.Ability{ buf_, pos_ + 0 }
    def b() -> MyGame.Example.Test:
        return MyGame.Example.Test{ buf_, pos_ + 8 }
    def c() -> MyGame.Example.Ability:
        return MyGame.Example.Ability{ buf_, pos_ + 12 }

def CreateStructOfStructs(b_:flatbuffers.builder, a_id:int, a_distance:int, b_a:int, b_b:int, c_id:int, c_distance:int):
    b_.Prep(4, 20)
    b_.Prep(4, 8)
    b_.PrependUint32(c_distance)
    b_.PrependUint32(c_id)
    b_.Prep(2, 4)
    b_.Pad(1)
    b_.PrependInt8(b_b)
    b_.PrependInt16(b_a)
    b_.Prep(4, 8)
    b_.PrependUint32(a_distance)
    b_.PrependUint32(a_id)
    return b_.Offset()

class StructOfStructsOfStructs : flatbuffers.handle
    def a() -> MyGame.Example.StructOfStructs:
        return MyGame.Example.StructOfStructs{ buf_, pos_ + 0 }

def CreateStructOfStructsOfStructs(b_:flatbuffers.builder, a_a_id:int, a_a_distance:int, a_b_a:int, a_b_b:int, a_c_id:int, a_c_distance:int):
    b_.Prep(4, 20)
    b_.Prep(4, 20)
    b_.Prep(4, 8)
    b_.PrependUint32(a_c_distance)
    b_.PrependUint32(a_c_id)
    b_.Prep(2, 4)
    b_.Pad(1)
    b_.PrependInt8(a_b_b)
    b_.PrependInt16(a_b_a)
    b_.Prep(4, 8)
    b_.PrependUint32(a_a_distance)
    b_.PrependUint32(a_a_id)
    return b_.Offset()

class Stat : flatbuffers.handle
    def id() -> string:
        return flatbuffers.field_string(buf_, pos_, 4)
    def val() -> int:
        return flatbuffers.field_int64(buf_, pos_, 6, 0)
    def count() -> int:
        return flatbuffers.field_uint16(buf_, pos_, 8, 0)

def GetRootAsStat(buf:string): return Stat { buf, flatbuffers.indirect(buf, 0) }

struct StatBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(3)
        return this
    def add_id(id:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(0, id)
        return this
    def add_val(val:int):
        b_.PrependInt64Slot(1, val, 0)
        return this
    def add_count(count:int):
        b_.PrependUint16Slot(2, count, 0)
        return this
    def end():
        return b_.EndObject()

class Referrable : flatbuffers.handle
    def id() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 4, 0)

def GetRootAsReferrable(buf:string): return Referrable { buf, flatbuffers.indirect(buf, 0) }

struct ReferrableBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(1)
        return this
    def add_id(id:int):
        b_.PrependUint64Slot(0, id, 0)
        return this
    def end():
        return b_.EndObject()

/// an example documentation comment: "monster object"
class Monster : flatbuffers.handle
    def pos() -> MyGame.Example.Vec3?:
        let o = flatbuffers.field_struct(buf_, pos_, 4)
        return if o: MyGame.Example.Vec3 { buf_, o } else: nil
    def mana() -> int:
        return flatbuffers.field_int16(buf_, pos_, 6, 150)
    def hp() -> int:
        return flatbuffers.field_int16(buf_, pos_, 8, 100)
    def name() -> string:
        return flatbuffers.field_string(buf_, pos_, 10)
    def inventory(i:int) -> int:
        return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 14) + i * 1)
    def inventory_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 14)
    def color() -> Color:
        return Color(flatbuffers.field_uint8(buf_, pos_, 16, 8))
    def test_type() -> Any:
        return Any(flatbuffers.field_uint8(buf_, pos_, 18, 0))
    def test_as_Monster():
        return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 20) }
    def test_as_TestSimpleTableWithEnum():
        return MyGame.Example.TestSimpleTableWithEnum { buf_, flatbuffers.field_table(buf_, pos_, 20) }
    def test_as_MyGame_Example2_Monster():
        return MyGame.Example2.Monster { buf_, flatbuffers.field_table(buf_, pos_, 20) }
    def test4(i:int) -> MyGame.Example.Test:
        return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 22) + i * 4 }
    def test4_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 22)
    def testarrayofstring(i:int) -> string:
        return flatbuffers.string(buf_, buf_.flatbuffers.field_vector(pos_, 24) + i * 4)
    def testarrayofstring_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 24)
    /// an example documentation comment: this will end up in the generated code
    /// multiline too
    def testarrayoftables(i:int) -> MyGame.Example.Monster:
        return MyGame.Example.Monster { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 26) + i * 4) }
    def testarrayoftables_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 26)
    def enemy() -> MyGame.Example.Monster?:
        let o = flatbuffers.field_table(buf_, pos_, 28)
        return if o: MyGame.Example.Monster { buf_, o } else: nil
    def testnestedflatbuffer(i:int) -> int:
        return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 30) + i * 1)
    def testnestedflatbuffer_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 30)
    def testempty() -> MyGame.Example.Stat?:
        let o = flatbuffers.field_table(buf_, pos_, 32)
        return if o: MyGame.Example.Stat { buf_, o } else: nil
    def testbool() -> bool:
        return bool(flatbuffers.field_int8(buf_, pos_, 34, 0))
    def testhashs32_fnv1() -> int:
        return flatbuffers.field_int32(buf_, pos_, 36, 0)
    def testhashu32_fnv1() -> int:
        return flatbuffers.field_uint32(buf_, pos_, 38, 0)
    def testhashs64_fnv1() -> int:
        return flatbuffers.field_int64(buf_, pos_, 40, 0)
    def testhashu64_fnv1() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 42, 0)
    def testhashs32_fnv1a() -> int:
        return flatbuffers.field_int32(buf_, pos_, 44, 0)
    def testhashu32_fnv1a() -> int:
        return flatbuffers.field_uint32(buf_, pos_, 46, 0)
    def testhashs64_fnv1a() -> int:
        return flatbuffers.field_int64(buf_, pos_, 48, 0)
    def testhashu64_fnv1a() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 50, 0)
    def testarrayofbools(i:int) -> bool:
        return read_int8_le(buf_, buf_.flatbuffers.field_vector(pos_, 52) + i * 1)
    def testarrayofbools_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 52)
    def testf() -> float:
        return flatbuffers.field_float32(buf_, pos_, 54, 3.14159)
    def testf2() -> float:
        return flatbuffers.field_float32(buf_, pos_, 56, 3.0)
    def testf3() -> float:
        return flatbuffers.field_float32(buf_, pos_, 58, 0.0)
    def testarrayofstring2(i:int) -> string:
        return flatbuffers.string(buf_, buf_.flatbuffers.field_vector(pos_, 60) + i * 4)
    def testarrayofstring2_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 60)
    def testarrayofsortedstruct(i:int) -> MyGame.Example.Ability:
        return MyGame.Example.Ability { buf_, flatbuffers.field_vector(buf_, pos_, 62) + i * 8 }
    def testarrayofsortedstruct_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 62)
    def flex(i:int) -> int:
        return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 64) + i * 1)
    def flex_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 64)
    def test5(i:int) -> MyGame.Example.Test:
        return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 66) + i * 4 }
    def test5_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 66)
    def vector_of_longs(i:int) -> int:
        return read_int64_le(buf_, buf_.flatbuffers.field_vector(pos_, 68) + i * 8)
    def vector_of_longs_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 68)
    def vector_of_doubles(i:int) -> float:
        return read_float64_le(buf_, buf_.flatbuffers.field_vector(pos_, 70) + i * 8)
    def vector_of_doubles_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 70)
    def parent_namespace_test() -> MyGame.InParentNamespace?:
        let o = flatbuffers.field_table(buf_, pos_, 72)
        return if o: MyGame.InParentNamespace { buf_, o } else: nil
    def vector_of_referrables(i:int) -> MyGame.Example.Referrable:
        return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 74) + i * 4) }
    def vector_of_referrables_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 74)
    def single_weak_reference() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 76, 0)
    def vector_of_weak_references(i:int) -> int:
        return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 78) + i * 8)
    def vector_of_weak_references_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 78)
    def vector_of_strong_referrables(i:int) -> MyGame.Example.Referrable:
        return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 80) + i * 4) }
    def vector_of_strong_referrables_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 80)
    def co_owning_reference() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 82, 0)
    def vector_of_co_owning_references(i:int) -> int:
        return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 84) + i * 8)
    def vector_of_co_owning_references_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 84)
    def non_owning_reference() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 86, 0)
    def vector_of_non_owning_references(i:int) -> int:
        return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 88) + i * 8)
    def vector_of_non_owning_references_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 88)
    def any_unique_type() -> AnyUniqueAliases:
        return AnyUniqueAliases(flatbuffers.field_uint8(buf_, pos_, 90, 0))
    def any_unique_as_M():
        return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 92) }
    def any_unique_as_TS():
        return MyGame.Example.TestSimpleTableWithEnum { buf_, flatbuffers.field_table(buf_, pos_, 92) }
    def any_unique_as_M2():
        return MyGame.Example2.Monster { buf_, flatbuffers.field_table(buf_, pos_, 92) }
    def any_ambiguous_type() -> AnyAmbiguousAliases:
        return AnyAmbiguousAliases(flatbuffers.field_uint8(buf_, pos_, 94, 0))
    def any_ambiguous_as_M1():
        return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
    def any_ambiguous_as_M2():
        return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
    def any_ambiguous_as_M3():
        return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
    def vector_of_enums(i:int) -> Color:
        return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 98) + i * 1)
    def vector_of_enums_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 98)
    def signed_enum() -> Race:
        return Race(flatbuffers.field_int8(buf_, pos_, 100, -1))
    def testrequirednestedflatbuffer(i:int) -> int:
        return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 102) + i * 1)
    def testrequirednestedflatbuffer_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 102)
    def scalar_key_sorted_tables(i:int) -> MyGame.Example.Stat:
        return MyGame.Example.Stat { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 104) + i * 4) }
    def scalar_key_sorted_tables_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 104)
    def native_inline() -> MyGame.Example.Test?:
        let o = flatbuffers.field_struct(buf_, pos_, 106)
        return if o: MyGame.Example.Test { buf_, o } else: nil
    def long_enum_non_enum_default() -> LongEnum:
        return LongEnum(flatbuffers.field_uint64(buf_, pos_, 108, 0))
    def long_enum_normal_default() -> LongEnum:
        return LongEnum(flatbuffers.field_uint64(buf_, pos_, 110, 2))
    def nan_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 112, nan)
    def inf_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 114, inf)
    def positive_inf_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 116, +inf)
    def infinity_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 118, infinity)
    def positive_infinity_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 120, +infinity)
    def negative_inf_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 122, -inf)
    def negative_infinity_default() -> float:
        return flatbuffers.field_float32(buf_, pos_, 124, -infinity)
    def double_inf_default() -> float:
        return flatbuffers.field_float64(buf_, pos_, 126, inf)

def GetRootAsMonster(buf:string): return Monster { buf, flatbuffers.indirect(buf, 0) }

struct MonsterBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(62)
        return this
    def add_pos(pos:flatbuffers.offset):
        b_.PrependStructSlot(0, pos)
        return this
    def add_mana(mana:int):
        b_.PrependInt16Slot(1, mana, 150)
        return this
    def add_hp(hp:int):
        b_.PrependInt16Slot(2, hp, 100)
        return this
    def add_name(name:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(3, name)
        return this
    def add_inventory(inventory:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(5, inventory)
        return this
    def add_color(color:Color):
        b_.PrependUint8Slot(6, color, 8)
        return this
    def add_test_type(test_type:Any):
        b_.PrependUint8Slot(7, test_type, 0)
        return this
    def add_test(test:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(8, test)
        return this
    def add_test4(test4:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(9, test4)
        return this
    def add_testarrayofstring(testarrayofstring:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(10, testarrayofstring)
        return this
    def add_testarrayoftables(testarrayoftables:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(11, testarrayoftables)
        return this
    def add_enemy(enemy:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(12, enemy)
        return this
    def add_testnestedflatbuffer(testnestedflatbuffer:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(13, testnestedflatbuffer)
        return this
    def add_testempty(testempty:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(14, testempty)
        return this
    def add_testbool(testbool:bool):
        b_.PrependBoolSlot(15, testbool, 0)
        return this
    def add_testhashs32_fnv1(testhashs32_fnv1:int):
        b_.PrependInt32Slot(16, testhashs32_fnv1, 0)
        return this
    def add_testhashu32_fnv1(testhashu32_fnv1:int):
        b_.PrependUint32Slot(17, testhashu32_fnv1, 0)
        return this
    def add_testhashs64_fnv1(testhashs64_fnv1:int):
        b_.PrependInt64Slot(18, testhashs64_fnv1, 0)
        return this
    def add_testhashu64_fnv1(testhashu64_fnv1:int):
        b_.PrependUint64Slot(19, testhashu64_fnv1, 0)
        return this
    def add_testhashs32_fnv1a(testhashs32_fnv1a:int):
        b_.PrependInt32Slot(20, testhashs32_fnv1a, 0)
        return this
    def add_testhashu32_fnv1a(testhashu32_fnv1a:int):
        b_.PrependUint32Slot(21, testhashu32_fnv1a, 0)
        return this
    def add_testhashs64_fnv1a(testhashs64_fnv1a:int):
        b_.PrependInt64Slot(22, testhashs64_fnv1a, 0)
        return this
    def add_testhashu64_fnv1a(testhashu64_fnv1a:int):
        b_.PrependUint64Slot(23, testhashu64_fnv1a, 0)
        return this
    def add_testarrayofbools(testarrayofbools:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(24, testarrayofbools)
        return this
    def add_testf(testf:float):
        b_.PrependFloat32Slot(25, testf, 3.14159)
        return this
    def add_testf2(testf2:float):
        b_.PrependFloat32Slot(26, testf2, 3.0)
        return this
    def add_testf3(testf3:float):
        b_.PrependFloat32Slot(27, testf3, 0.0)
        return this
    def add_testarrayofstring2(testarrayofstring2:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(28, testarrayofstring2)
        return this
    def add_testarrayofsortedstruct(testarrayofsortedstruct:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct)
        return this
    def add_flex(flex:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(30, flex)
        return this
    def add_test5(test5:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(31, test5)
        return this
    def add_vector_of_longs(vector_of_longs:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(32, vector_of_longs)
        return this
    def add_vector_of_doubles(vector_of_doubles:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(33, vector_of_doubles)
        return this
    def add_parent_namespace_test(parent_namespace_test:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(34, parent_namespace_test)
        return this
    def add_vector_of_referrables(vector_of_referrables:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(35, vector_of_referrables)
        return this
    def add_single_weak_reference(single_weak_reference:int):
        b_.PrependUint64Slot(36, single_weak_reference, 0)
        return this
    def add_vector_of_weak_references(vector_of_weak_references:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(37, vector_of_weak_references)
        return this
    def add_vector_of_strong_referrables(vector_of_strong_referrables:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(38, vector_of_strong_referrables)
        return this
    def add_co_owning_reference(co_owning_reference:int):
        b_.PrependUint64Slot(39, co_owning_reference, 0)
        return this
    def add_vector_of_co_owning_references(vector_of_co_owning_references:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(40, vector_of_co_owning_references)
        return this
    def add_non_owning_reference(non_owning_reference:int):
        b_.PrependUint64Slot(41, non_owning_reference, 0)
        return this
    def add_vector_of_non_owning_references(vector_of_non_owning_references:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(42, vector_of_non_owning_references)
        return this
    def add_any_unique_type(any_unique_type:AnyUniqueAliases):
        b_.PrependUint8Slot(43, any_unique_type, 0)
        return this
    def add_any_unique(any_unique:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(44, any_unique)
        return this
    def add_any_ambiguous_type(any_ambiguous_type:AnyAmbiguousAliases):
        b_.PrependUint8Slot(45, any_ambiguous_type, 0)
        return this
    def add_any_ambiguous(any_ambiguous:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(46, any_ambiguous)
        return this
    def add_vector_of_enums(vector_of_enums:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(47, vector_of_enums)
        return this
    def add_signed_enum(signed_enum:Race):
        b_.PrependInt8Slot(48, signed_enum, -1)
        return this
    def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer)
        return this
    def add_scalar_key_sorted_tables(scalar_key_sorted_tables:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(50, scalar_key_sorted_tables)
        return this
    def add_native_inline(native_inline:flatbuffers.offset):
        b_.PrependStructSlot(51, native_inline)
        return this
    def add_long_enum_non_enum_default(long_enum_non_enum_default:LongEnum):
        b_.PrependUint64Slot(52, long_enum_non_enum_default, 0)
        return this
    def add_long_enum_normal_default(long_enum_normal_default:LongEnum):
        b_.PrependUint64Slot(53, long_enum_normal_default, 2)
        return this
    def add_nan_default(nan_default:float):
        b_.PrependFloat32Slot(54, nan_default, nan)
        return this
    def add_inf_default(inf_default:float):
        b_.PrependFloat32Slot(55, inf_default, inf)
        return this
    def add_positive_inf_default(positive_inf_default:float):
        b_.PrependFloat32Slot(56, positive_inf_default, +inf)
        return this
    def add_infinity_default(infinity_default:float):
        b_.PrependFloat32Slot(57, infinity_default, infinity)
        return this
    def add_positive_infinity_default(positive_infinity_default:float):
        b_.PrependFloat32Slot(58, positive_infinity_default, +infinity)
        return this
    def add_negative_inf_default(negative_inf_default:float):
        b_.PrependFloat32Slot(59, negative_inf_default, -inf)
        return this
    def add_negative_infinity_default(negative_infinity_default:float):
        b_.PrependFloat32Slot(60, negative_infinity_default, -infinity)
        return this
    def add_double_inf_default(double_inf_default:float):
        b_.PrependFloat64Slot(61, double_inf_default, inf)
        return this
    def end():
        return b_.EndObject()

def MonsterStartInventoryVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateInventoryVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

def MonsterStartTest4Vector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 2)

def MonsterStartTestarrayofstringVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayofstringVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestarrayoftablesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayoftablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestnestedflatbufferVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateTestnestedflatbufferVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestarrayofboolsVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateTestarrayofboolsVector(b_:flatbuffers.builder, v_:[bool]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependBool(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestarrayofstring2Vector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayofstring2Vector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 4)

def MonsterStartFlexVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateFlexVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

def MonsterStartTest5Vector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 2)

def MonsterStartVectorOfLongsVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfLongsVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependInt64(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfDoublesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfDoublesVector(b_:flatbuffers.builder, v_:[float]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependFloat64(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfReferrablesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateVectorOfReferrablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfWeakReferencesVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependUint64(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateVectorOfStrongReferrablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfCoOwningReferencesVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependUint64(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfNonOwningReferencesVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependUint64(e_)
    return b_.EndVector(v_.length)

def MonsterStartVectorOfEnumsVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateVectorOfEnumsVector(b_:flatbuffers.builder, v_:[Color]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(4, n_, 4)
def MonsterCreateScalarKeySortedTablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
    b_.StartVector(4, v_.length, 4)
    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
    return b_.EndVector(v_.length)

class TypeAliases : flatbuffers.handle
    def i8() -> int:
        return flatbuffers.field_int8(buf_, pos_, 4, 0)
    def u8() -> int:
        return flatbuffers.field_uint8(buf_, pos_, 6, 0)
    def i16() -> int:
        return flatbuffers.field_int16(buf_, pos_, 8, 0)
    def u16() -> int:
        return flatbuffers.field_uint16(buf_, pos_, 10, 0)
    def i32() -> int:
        return flatbuffers.field_int32(buf_, pos_, 12, 0)
    def u32() -> int:
        return flatbuffers.field_uint32(buf_, pos_, 14, 0)
    def i64() -> int:
        return flatbuffers.field_int64(buf_, pos_, 16, 0)
    def u64() -> int:
        return flatbuffers.field_uint64(buf_, pos_, 18, 0)
    def f32() -> float:
        return flatbuffers.field_float32(buf_, pos_, 20, 0.0)
    def f64() -> float:
        return flatbuffers.field_float64(buf_, pos_, 22, 0.0)
    def v8(i:int) -> int:
        return read_int8_le(buf_, buf_.flatbuffers.field_vector(pos_, 24) + i * 1)
    def v8_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 24)
    def vf64(i:int) -> float:
        return read_float64_le(buf_, buf_.flatbuffers.field_vector(pos_, 26) + i * 8)
    def vf64_length() -> int:
        return flatbuffers.field_vector_len(buf_, pos_, 26)

def GetRootAsTypeAliases(buf:string): return TypeAliases { buf, flatbuffers.indirect(buf, 0) }

struct TypeAliasesBuilder:
    b_:flatbuffers.builder
    def start():
        b_.StartObject(12)
        return this
    def add_i8(i8:int):
        b_.PrependInt8Slot(0, i8, 0)
        return this
    def add_u8(u8:int):
        b_.PrependUint8Slot(1, u8, 0)
        return this
    def add_i16(i16:int):
        b_.PrependInt16Slot(2, i16, 0)
        return this
    def add_u16(u16:int):
        b_.PrependUint16Slot(3, u16, 0)
        return this
    def add_i32(i32:int):
        b_.PrependInt32Slot(4, i32, 0)
        return this
    def add_u32(u32:int):
        b_.PrependUint32Slot(5, u32, 0)
        return this
    def add_i64(i64:int):
        b_.PrependInt64Slot(6, i64, 0)
        return this
    def add_u64(u64:int):
        b_.PrependUint64Slot(7, u64, 0)
        return this
    def add_f32(f32:float):
        b_.PrependFloat32Slot(8, f32, 0.0)
        return this
    def add_f64(f64:float):
        b_.PrependFloat64Slot(9, f64, 0.0)
        return this
    def add_v8(v8:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(10, v8)
        return this
    def add_vf64(vf64:flatbuffers.offset):
        b_.PrependUOffsetTRelativeSlot(11, vf64)
        return this
    def end():
        return b_.EndObject()

def TypeAliasesStartV8Vector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(1, n_, 1)
def TypeAliasesCreateV8Vector(b_:flatbuffers.builder, v_:[int]):
    b_.StartVector(1, v_.length, 1)
    reverse(v_) e_: b_.PrependInt8(e_)
    return b_.EndVector(v_.length)

def TypeAliasesStartVf64Vector(b_:flatbuffers.builder, n_:int):
    b_.StartVector(8, n_, 8)
def TypeAliasesCreateVf64Vector(b_:flatbuffers.builder, v_:[float]):
    b_.StartVector(8, v_.length, 8)
    reverse(v_) e_: b_.PrependFloat64(e_)
    return b_.EndVector(v_.length)