Merge commit '0f6aab9da6fe982218a01f4a5b896e65fcced437' as 'third_party/flatbuffers'

third_party/flatbuffers/tests/ts/my-game/example/ability.d.ts

@@ -0,0 +1,21 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class Ability implements flatbuffers.IUnpackableObject<AbilityT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Ability;
+    id(): number;
+    mutate_id(value: number): boolean;
+    distance(): number;
+    mutate_distance(value: number): boolean;
+    static getFullyQualifiedName(): string;
+    static sizeOf(): number;
+    static createAbility(builder: flatbuffers.Builder, id: number, distance: number): flatbuffers.Offset;
+    unpack(): AbilityT;
+    unpackTo(_o: AbilityT): void;
+}
+export declare class AbilityT implements flatbuffers.IGeneratedObject {
+    id: number;
+    distance: number;
+    constructor(id?: number, distance?: number);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/ability.js

@@ -0,0 +1,54 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+export class Ability {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    id() {
+        return this.bb.readUint32(this.bb_pos);
+    }
+    mutate_id(value) {
+        this.bb.writeUint32(this.bb_pos + 0, value);
+        return true;
+    }
+    distance() {
+        return this.bb.readUint32(this.bb_pos + 4);
+    }
+    mutate_distance(value) {
+        this.bb.writeUint32(this.bb_pos + 4, value);
+        return true;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.Ability';
+    }
+    static sizeOf() {
+        return 8;
+    }
+    static createAbility(builder, id, distance) {
+        builder.prep(4, 8);
+        builder.writeInt32(distance);
+        builder.writeInt32(id);
+        return builder.offset();
+    }
+    unpack() {
+        return new AbilityT(this.id(), this.distance());
+    }
+    unpackTo(_o) {
+        _o.id = this.id();
+        _o.distance = this.distance();
+    }
+}
+export class AbilityT {
+    constructor(id = 0, distance = 0) {
+        this.id = id;
+        this.distance = distance;
+    }
+    pack(builder) {
+        return Ability.createAbility(builder, this.id, this.distance);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/ability.ts

@@ -0,0 +1,79 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class Ability implements flatbuffers.IUnpackableObject<AbilityT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Ability {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+id():number {
+  return this.bb!.readUint32(this.bb_pos);
+}
+
+mutate_id(value:number):boolean {
+  this.bb!.writeUint32(this.bb_pos + 0, value);
+  return true;
+}
+
+distance():number {
+  return this.bb!.readUint32(this.bb_pos + 4);
+}
+
+mutate_distance(value:number):boolean {
+  this.bb!.writeUint32(this.bb_pos + 4, value);
+  return true;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.Ability';
+}
+
+static sizeOf():number {
+  return 8;
+}
+
+static createAbility(builder:flatbuffers.Builder, id: number, distance: number):flatbuffers.Offset {
+  builder.prep(4, 8);
+  builder.writeInt32(distance);
+  builder.writeInt32(id);
+  return builder.offset();
+}
+
+
+unpack(): AbilityT {
+  return new AbilityT(
+    this.id(),
+    this.distance()
+  );
+}
+
+
+unpackTo(_o: AbilityT): void {
+  _o.id = this.id();
+  _o.distance = this.distance();
+}
+}
+
+export class AbilityT implements flatbuffers.IGeneratedObject {
+constructor(
+  public id: number = 0,
+  public distance: number = 0
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return Ability.createAbility(builder,
+    this.id,
+    this.distance
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/any-ambiguous-aliases.d.ts

@@ -0,0 +1,9 @@
+import { Monster } from '../../my-game/example/monster.js';
+export declare enum AnyAmbiguousAliases {
+    NONE = 0,
+    M1 = 1,
+    M2 = 2,
+    M3 = 3
+}
+export declare function unionToAnyAmbiguousAliases(type: AnyAmbiguousAliases, accessor: (obj: Monster) => Monster | null): Monster | null;
+export declare function unionListToAnyAmbiguousAliases(type: AnyAmbiguousAliases, accessor: (index: number, obj: Monster) => Monster | null, index: number): Monster | null;

third_party/flatbuffers/tests/ts/my-game/example/any-ambiguous-aliases.js

@@ -0,0 +1,28 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import { Monster } from '../../my-game/example/monster.js';
+export var AnyAmbiguousAliases;
+(function (AnyAmbiguousAliases) {
+    AnyAmbiguousAliases[AnyAmbiguousAliases["NONE"] = 0] = "NONE";
+    AnyAmbiguousAliases[AnyAmbiguousAliases["M1"] = 1] = "M1";
+    AnyAmbiguousAliases[AnyAmbiguousAliases["M2"] = 2] = "M2";
+    AnyAmbiguousAliases[AnyAmbiguousAliases["M3"] = 3] = "M3";
+})(AnyAmbiguousAliases || (AnyAmbiguousAliases = {}));
+export function unionToAnyAmbiguousAliases(type, accessor) {
+    switch (AnyAmbiguousAliases[type]) {
+        case 'NONE': return null;
+        case 'M1': return accessor(new Monster());
+        case 'M2': return accessor(new Monster());
+        case 'M3': return accessor(new Monster());
+        default: return null;
+    }
+}
+export function unionListToAnyAmbiguousAliases(type, accessor, index) {
+    switch (AnyAmbiguousAliases[type]) {
+        case 'NONE': return null;
+        case 'M1': return accessor(index, new Monster());
+        case 'M2': return accessor(index, new Monster());
+        case 'M3': return accessor(index, new Monster());
+        default: return null;
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/any-ambiguous-aliases.ts

@@ -0,0 +1,40 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import { Monster, MonsterT } from '../../my-game/example/monster.js';
+
+
+export enum AnyAmbiguousAliases {
+  NONE = 0,
+  M1 = 1,
+  M2 = 2,
+  M3 = 3
+}
+
+export function unionToAnyAmbiguousAliases(
+  type: AnyAmbiguousAliases,
+  accessor: (obj:Monster) => Monster|null
+): Monster|null {
+  switch(AnyAmbiguousAliases[type]) {
+    case 'NONE': return null; 
+    case 'M1': return accessor(new Monster())! as Monster;
+    case 'M2': return accessor(new Monster())! as Monster;
+    case 'M3': return accessor(new Monster())! as Monster;
+    default: return null;
+  }
+}
+
+export function unionListToAnyAmbiguousAliases(
+  type: AnyAmbiguousAliases, 
+  accessor: (index: number, obj:Monster) => Monster|null, 
+  index: number
+): Monster|null {
+  switch(AnyAmbiguousAliases[type]) {
+    case 'NONE': return null; 
+    case 'M1': return accessor(index, new Monster())! as Monster;
+    case 'M2': return accessor(index, new Monster())! as Monster;
+    case 'M3': return accessor(index, new Monster())! as Monster;
+    default: return null;
+  }
+}

third_party/flatbuffers/tests/ts/my-game/example/any-unique-aliases.d.ts

@@ -0,0 +1,11 @@
+import { Monster as MyGame_Example2_Monster } from '../../my-game/example2/monster.js';
+import { Monster } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum } from '../../my-game/example/test-simple-table-with-enum.js';
+export declare enum AnyUniqueAliases {
+    NONE = 0,
+    M = 1,
+    TS = 2,
+    M2 = 3
+}
+export declare function unionToAnyUniqueAliases(type: AnyUniqueAliases, accessor: (obj: Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum) => Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null): Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null;
+export declare function unionListToAnyUniqueAliases(type: AnyUniqueAliases, accessor: (index: number, obj: Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum) => Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null, index: number): Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null;

third_party/flatbuffers/tests/ts/my-game/example/any-unique-aliases.js

@@ -0,0 +1,30 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import { Monster as MyGame_Example2_Monster } from '../../my-game/example2/monster.js';
+import { Monster } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum } from '../../my-game/example/test-simple-table-with-enum.js';
+export var AnyUniqueAliases;
+(function (AnyUniqueAliases) {
+    AnyUniqueAliases[AnyUniqueAliases["NONE"] = 0] = "NONE";
+    AnyUniqueAliases[AnyUniqueAliases["M"] = 1] = "M";
+    AnyUniqueAliases[AnyUniqueAliases["TS"] = 2] = "TS";
+    AnyUniqueAliases[AnyUniqueAliases["M2"] = 3] = "M2";
+})(AnyUniqueAliases || (AnyUniqueAliases = {}));
+export function unionToAnyUniqueAliases(type, accessor) {
+    switch (AnyUniqueAliases[type]) {
+        case 'NONE': return null;
+        case 'M': return accessor(new Monster());
+        case 'TS': return accessor(new TestSimpleTableWithEnum());
+        case 'M2': return accessor(new MyGame_Example2_Monster());
+        default: return null;
+    }
+}
+export function unionListToAnyUniqueAliases(type, accessor, index) {
+    switch (AnyUniqueAliases[type]) {
+        case 'NONE': return null;
+        case 'M': return accessor(index, new Monster());
+        case 'TS': return accessor(index, new TestSimpleTableWithEnum());
+        case 'M2': return accessor(index, new MyGame_Example2_Monster());
+        default: return null;
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/any-unique-aliases.ts

@@ -0,0 +1,42 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import { Monster as MyGame_Example2_Monster, MonsterT as MyGame_Example2_MonsterT } from '../../my-game/example2/monster.js';
+import { Monster, MonsterT } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum, TestSimpleTableWithEnumT } from '../../my-game/example/test-simple-table-with-enum.js';
+
+
+export enum AnyUniqueAliases {
+  NONE = 0,
+  M = 1,
+  TS = 2,
+  M2 = 3
+}
+
+export function unionToAnyUniqueAliases(
+  type: AnyUniqueAliases,
+  accessor: (obj:Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum) => Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null
+): Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null {
+  switch(AnyUniqueAliases[type]) {
+    case 'NONE': return null; 
+    case 'M': return accessor(new Monster())! as Monster;
+    case 'TS': return accessor(new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
+    case 'M2': return accessor(new MyGame_Example2_Monster())! as MyGame_Example2_Monster;
+    default: return null;
+  }
+}
+
+export function unionListToAnyUniqueAliases(
+  type: AnyUniqueAliases, 
+  accessor: (index: number, obj:Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum) => Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null, 
+  index: number
+): Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null {
+  switch(AnyUniqueAliases[type]) {
+    case 'NONE': return null; 
+    case 'M': return accessor(index, new Monster())! as Monster;
+    case 'TS': return accessor(index, new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
+    case 'M2': return accessor(index, new MyGame_Example2_Monster())! as MyGame_Example2_Monster;
+    default: return null;
+  }
+}

third_party/flatbuffers/tests/ts/my-game/example/any.d.ts

@@ -0,0 +1,11 @@
+import { Monster as MyGame_Example2_Monster } from '../../my-game/example2/monster.js';
+import { Monster } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum } from '../../my-game/example/test-simple-table-with-enum.js';
+export declare enum Any {
+    NONE = 0,
+    Monster = 1,
+    TestSimpleTableWithEnum = 2,
+    MyGame_Example2_Monster = 3
+}
+export declare function unionToAny(type: Any, accessor: (obj: Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum) => Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null): Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null;
+export declare function unionListToAny(type: Any, accessor: (index: number, obj: Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum) => Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null, index: number): Monster | MyGame_Example2_Monster | TestSimpleTableWithEnum | null;

third_party/flatbuffers/tests/ts/my-game/example/any.js

@@ -0,0 +1,30 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import { Monster as MyGame_Example2_Monster } from '../../my-game/example2/monster.js';
+import { Monster } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum } from '../../my-game/example/test-simple-table-with-enum.js';
+export var Any;
+(function (Any) {
+    Any[Any["NONE"] = 0] = "NONE";
+    Any[Any["Monster"] = 1] = "Monster";
+    Any[Any["TestSimpleTableWithEnum"] = 2] = "TestSimpleTableWithEnum";
+    Any[Any["MyGame_Example2_Monster"] = 3] = "MyGame_Example2_Monster";
+})(Any || (Any = {}));
+export function unionToAny(type, accessor) {
+    switch (Any[type]) {
+        case 'NONE': return null;
+        case 'Monster': return accessor(new Monster());
+        case 'TestSimpleTableWithEnum': return accessor(new TestSimpleTableWithEnum());
+        case 'MyGame_Example2_Monster': return accessor(new MyGame_Example2_Monster());
+        default: return null;
+    }
+}
+export function unionListToAny(type, accessor, index) {
+    switch (Any[type]) {
+        case 'NONE': return null;
+        case 'Monster': return accessor(index, new Monster());
+        case 'TestSimpleTableWithEnum': return accessor(index, new TestSimpleTableWithEnum());
+        case 'MyGame_Example2_Monster': return accessor(index, new MyGame_Example2_Monster());
+        default: return null;
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/any.ts

@@ -0,0 +1,42 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import { Monster as MyGame_Example2_Monster, MonsterT as MyGame_Example2_MonsterT } from '../../my-game/example2/monster.js';
+import { Monster, MonsterT } from '../../my-game/example/monster.js';
+import { TestSimpleTableWithEnum, TestSimpleTableWithEnumT } from '../../my-game/example/test-simple-table-with-enum.js';
+
+
+export enum Any {
+  NONE = 0,
+  Monster = 1,
+  TestSimpleTableWithEnum = 2,
+  MyGame_Example2_Monster = 3
+}
+
+export function unionToAny(
+  type: Any,
+  accessor: (obj:Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum) => Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null
+): Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null {
+  switch(Any[type]) {
+    case 'NONE': return null; 
+    case 'Monster': return accessor(new Monster())! as Monster;
+    case 'TestSimpleTableWithEnum': return accessor(new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
+    case 'MyGame_Example2_Monster': return accessor(new MyGame_Example2_Monster())! as MyGame_Example2_Monster;
+    default: return null;
+  }
+}
+
+export function unionListToAny(
+  type: Any, 
+  accessor: (index: number, obj:Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum) => Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null, 
+  index: number
+): Monster|MyGame_Example2_Monster|TestSimpleTableWithEnum|null {
+  switch(Any[type]) {
+    case 'NONE': return null; 
+    case 'Monster': return accessor(index, new Monster())! as Monster;
+    case 'TestSimpleTableWithEnum': return accessor(index, new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
+    case 'MyGame_Example2_Monster': return accessor(index, new MyGame_Example2_Monster())! as MyGame_Example2_Monster;
+    default: return null;
+  }
+}

third_party/flatbuffers/tests/ts/my-game/example/color.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Composite components of Monster color.
+ */
+export declare enum Color {
+    Red = 1,
+    /**
+     * \brief color Green
+     * Green is bit_flag with value (1u << 1)
+     */
+    Green = 2,
+    /**
+     * \brief color Blue (1u << 3)
+     */
+    Blue = 8
+}

third_party/flatbuffers/tests/ts/my-game/example/color.js

@@ -0,0 +1,18 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+/**
+ * Composite components of Monster color.
+ */
+export var Color;
+(function (Color) {
+    Color[Color["Red"] = 1] = "Red";
+    /**
+     * \brief color Green
+     * Green is bit_flag with value (1u << 1)
+     */
+    Color[Color["Green"] = 2] = "Green";
+    /**
+     * \brief color Blue (1u << 3)
+     */
+    Color[Color["Blue"] = 8] = "Blue";
+})(Color || (Color = {}));

third_party/flatbuffers/tests/ts/my-game/example/color.ts

@@ -0,0 +1,21 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+/**
+ * Composite components of Monster color.
+ */
+export enum Color {
+  Red = 1,
+
+  /**
+   * \brief color Green
+   * Green is bit_flag with value (1u << 1)
+   */
+  Green = 2,
+
+  /**
+   * \brief color Blue (1u << 3)
+   */
+  Blue = 8
+}

third_party/flatbuffers/tests/ts/my-game/example/long-enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum LongEnum {
+    LongOne = "2",
+    LongTwo = "4",
+    LongBig = "1099511627776"
+}

third_party/flatbuffers/tests/ts/my-game/example/long-enum.js

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var LongEnum;
+(function (LongEnum) {
+    LongEnum["LongOne"] = "2";
+    LongEnum["LongTwo"] = "4";
+    LongEnum["LongBig"] = "1099511627776";
+})(LongEnum || (LongEnum = {}));

third_party/flatbuffers/tests/ts/my-game/example/long-enum.ts

@@ -0,0 +1,9 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+export enum LongEnum {
+  LongOne = '2',
+  LongTwo = '4',
+  LongBig = '1099511627776'
+}

third_party/flatbuffers/tests/ts/my-game/example/monster.d.ts

@@ -0,0 +1,325 @@
+import * as flatbuffers from 'flatbuffers';
+import { MonsterT as MyGame_Example2_MonsterT } from '../../my-game/example2/monster.js';
+import { Ability, AbilityT } from '../../my-game/example/ability.js';
+import { Any } from '../../my-game/example/any.js';
+import { AnyAmbiguousAliases } from '../../my-game/example/any-ambiguous-aliases.js';
+import { AnyUniqueAliases } from '../../my-game/example/any-unique-aliases.js';
+import { Color } from '../../my-game/example/color.js';
+import { Race } from '../../my-game/example/race.js';
+import { Referrable, ReferrableT } from '../../my-game/example/referrable.js';
+import { Stat, StatT } from '../../my-game/example/stat.js';
+import { Test, TestT } from '../../my-game/example/test.js';
+import { TestSimpleTableWithEnumT } from '../../my-game/example/test-simple-table-with-enum.js';
+import { Vec3, Vec3T } from '../../my-game/example/vec3.js';
+import { InParentNamespace, InParentNamespaceT } from '../../my-game/in-parent-namespace.js';
+/**
+ * an example documentation comment: "monster object"
+ */
+export declare class Monster implements flatbuffers.IUnpackableObject<MonsterT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Monster;
+    static getRootAsMonster(bb: flatbuffers.ByteBuffer, obj?: Monster): Monster;
+    static getSizePrefixedRootAsMonster(bb: flatbuffers.ByteBuffer, obj?: Monster): Monster;
+    static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean;
+    pos(obj?: Vec3): Vec3 | null;
+    mana(): number;
+    mutate_mana(value: number): boolean;
+    hp(): number;
+    mutate_hp(value: number): boolean;
+    name(): string | null;
+    name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    inventory(index: number): number | null;
+    inventoryLength(): number;
+    inventoryArray(): Uint8Array | null;
+    color(): Color;
+    mutate_color(value: Color): boolean;
+    testType(): Any;
+    test<T extends flatbuffers.Table>(obj: any): any | null;
+    test4(index: number, obj?: Test): Test | null;
+    test4Length(): number;
+    testarrayofstring(index: number): string;
+    testarrayofstring(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
+    testarrayofstringLength(): number;
+    /**
+     * an example documentation comment: this will end up in the generated code
+     * multiline too
+     */
+    testarrayoftables(index: number, obj?: Monster): Monster | null;
+    testarrayoftablesLength(): number;
+    enemy(obj?: Monster): Monster | null;
+    testnestedflatbuffer(index: number): number | null;
+    testnestedflatbufferLength(): number;
+    testnestedflatbufferArray(): Uint8Array | null;
+    testempty(obj?: Stat): Stat | null;
+    testbool(): boolean;
+    mutate_testbool(value: boolean): boolean;
+    testhashs32Fnv1(): number;
+    mutate_testhashs32_fnv1(value: number): boolean;
+    testhashu32Fnv1(): number;
+    mutate_testhashu32_fnv1(value: number): boolean;
+    testhashs64Fnv1(): bigint;
+    mutate_testhashs64_fnv1(value: bigint): boolean;
+    testhashu64Fnv1(): bigint;
+    mutate_testhashu64_fnv1(value: bigint): boolean;
+    testhashs32Fnv1a(): number;
+    mutate_testhashs32_fnv1a(value: number): boolean;
+    testhashu32Fnv1a(): number;
+    mutate_testhashu32_fnv1a(value: number): boolean;
+    testhashs64Fnv1a(): bigint;
+    mutate_testhashs64_fnv1a(value: bigint): boolean;
+    testhashu64Fnv1a(): bigint;
+    mutate_testhashu64_fnv1a(value: bigint): boolean;
+    testarrayofbools(index: number): boolean | null;
+    testarrayofboolsLength(): number;
+    testarrayofboolsArray(): Int8Array | null;
+    testf(): number;
+    mutate_testf(value: number): boolean;
+    testf2(): number;
+    mutate_testf2(value: number): boolean;
+    testf3(): number;
+    mutate_testf3(value: number): boolean;
+    testarrayofstring2(index: number): string;
+    testarrayofstring2(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
+    testarrayofstring2Length(): number;
+    testarrayofsortedstruct(index: number, obj?: Ability): Ability | null;
+    testarrayofsortedstructLength(): number;
+    flex(index: number): number | null;
+    flexLength(): number;
+    flexArray(): Uint8Array | null;
+    test5(index: number, obj?: Test): Test | null;
+    test5Length(): number;
+    vectorOfLongs(index: number): bigint | null;
+    vectorOfLongsLength(): number;
+    vectorOfDoubles(index: number): number | null;
+    vectorOfDoublesLength(): number;
+    vectorOfDoublesArray(): Float64Array | null;
+    parentNamespaceTest(obj?: InParentNamespace): InParentNamespace | null;
+    vectorOfReferrables(index: number, obj?: Referrable): Referrable | null;
+    vectorOfReferrablesLength(): number;
+    singleWeakReference(): bigint;
+    mutate_single_weak_reference(value: bigint): boolean;
+    vectorOfWeakReferences(index: number): bigint | null;
+    vectorOfWeakReferencesLength(): number;
+    vectorOfStrongReferrables(index: number, obj?: Referrable): Referrable | null;
+    vectorOfStrongReferrablesLength(): number;
+    coOwningReference(): bigint;
+    mutate_co_owning_reference(value: bigint): boolean;
+    vectorOfCoOwningReferences(index: number): bigint | null;
+    vectorOfCoOwningReferencesLength(): number;
+    nonOwningReference(): bigint;
+    mutate_non_owning_reference(value: bigint): boolean;
+    vectorOfNonOwningReferences(index: number): bigint | null;
+    vectorOfNonOwningReferencesLength(): number;
+    anyUniqueType(): AnyUniqueAliases;
+    anyUnique<T extends flatbuffers.Table>(obj: any): any | null;
+    anyAmbiguousType(): AnyAmbiguousAliases;
+    anyAmbiguous<T extends flatbuffers.Table>(obj: any): any | null;
+    vectorOfEnums(index: number): Color | null;
+    vectorOfEnumsLength(): number;
+    vectorOfEnumsArray(): Uint8Array | null;
+    signedEnum(): Race;
+    mutate_signed_enum(value: Race): boolean;
+    testrequirednestedflatbuffer(index: number): number | null;
+    testrequirednestedflatbufferLength(): number;
+    testrequirednestedflatbufferArray(): Uint8Array | null;
+    scalarKeySortedTables(index: number, obj?: Stat): Stat | null;
+    scalarKeySortedTablesLength(): number;
+    nativeInline(obj?: Test): Test | null;
+    longEnumNonEnumDefault(): bigint;
+    mutate_long_enum_non_enum_default(value: bigint): boolean;
+    longEnumNormalDefault(): bigint;
+    mutate_long_enum_normal_default(value: bigint): boolean;
+    nanDefault(): number;
+    mutate_nan_default(value: number): boolean;
+    infDefault(): number;
+    mutate_inf_default(value: number): boolean;
+    positiveInfDefault(): number;
+    mutate_positive_inf_default(value: number): boolean;
+    infinityDefault(): number;
+    mutate_infinity_default(value: number): boolean;
+    positiveInfinityDefault(): number;
+    mutate_positive_infinity_default(value: number): boolean;
+    negativeInfDefault(): number;
+    mutate_negative_inf_default(value: number): boolean;
+    negativeInfinityDefault(): number;
+    mutate_negative_infinity_default(value: number): boolean;
+    doubleInfDefault(): number;
+    mutate_double_inf_default(value: number): boolean;
+    static getFullyQualifiedName(): string;
+    static startMonster(builder: flatbuffers.Builder): void;
+    static addPos(builder: flatbuffers.Builder, posOffset: flatbuffers.Offset): void;
+    static addMana(builder: flatbuffers.Builder, mana: number): void;
+    static addHp(builder: flatbuffers.Builder, hp: number): void;
+    static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
+    static addInventory(builder: flatbuffers.Builder, inventoryOffset: flatbuffers.Offset): void;
+    static createInventoryVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startInventoryVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addColor(builder: flatbuffers.Builder, color: Color): void;
+    static addTestType(builder: flatbuffers.Builder, testType: Any): void;
+    static addTest(builder: flatbuffers.Builder, testOffset: flatbuffers.Offset): void;
+    static addTest4(builder: flatbuffers.Builder, test4Offset: flatbuffers.Offset): void;
+    static startTest4Vector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTestarrayofstring(builder: flatbuffers.Builder, testarrayofstringOffset: flatbuffers.Offset): void;
+    static createTestarrayofstringVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startTestarrayofstringVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTestarrayoftables(builder: flatbuffers.Builder, testarrayoftablesOffset: flatbuffers.Offset): void;
+    static createTestarrayoftablesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startTestarrayoftablesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addEnemy(builder: flatbuffers.Builder, enemyOffset: flatbuffers.Offset): void;
+    static addTestnestedflatbuffer(builder: flatbuffers.Builder, testnestedflatbufferOffset: flatbuffers.Offset): void;
+    static createTestnestedflatbufferVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startTestnestedflatbufferVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTestempty(builder: flatbuffers.Builder, testemptyOffset: flatbuffers.Offset): void;
+    static addTestbool(builder: flatbuffers.Builder, testbool: boolean): void;
+    static addTesthashs32Fnv1(builder: flatbuffers.Builder, testhashs32Fnv1: number): void;
+    static addTesthashu32Fnv1(builder: flatbuffers.Builder, testhashu32Fnv1: number): void;
+    static addTesthashs64Fnv1(builder: flatbuffers.Builder, testhashs64Fnv1: bigint): void;
+    static addTesthashu64Fnv1(builder: flatbuffers.Builder, testhashu64Fnv1: bigint): void;
+    static addTesthashs32Fnv1a(builder: flatbuffers.Builder, testhashs32Fnv1a: number): void;
+    static addTesthashu32Fnv1a(builder: flatbuffers.Builder, testhashu32Fnv1a: number): void;
+    static addTesthashs64Fnv1a(builder: flatbuffers.Builder, testhashs64Fnv1a: bigint): void;
+    static addTesthashu64Fnv1a(builder: flatbuffers.Builder, testhashu64Fnv1a: bigint): void;
+    static addTestarrayofbools(builder: flatbuffers.Builder, testarrayofboolsOffset: flatbuffers.Offset): void;
+    static createTestarrayofboolsVector(builder: flatbuffers.Builder, data: boolean[]): flatbuffers.Offset;
+    static startTestarrayofboolsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTestf(builder: flatbuffers.Builder, testf: number): void;
+    static addTestf2(builder: flatbuffers.Builder, testf2: number): void;
+    static addTestf3(builder: flatbuffers.Builder, testf3: number): void;
+    static addTestarrayofstring2(builder: flatbuffers.Builder, testarrayofstring2Offset: flatbuffers.Offset): void;
+    static createTestarrayofstring2Vector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startTestarrayofstring2Vector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTestarrayofsortedstruct(builder: flatbuffers.Builder, testarrayofsortedstructOffset: flatbuffers.Offset): void;
+    static startTestarrayofsortedstructVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addFlex(builder: flatbuffers.Builder, flexOffset: flatbuffers.Offset): void;
+    static createFlexVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startFlexVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTest5(builder: flatbuffers.Builder, test5Offset: flatbuffers.Offset): void;
+    static startTest5Vector(builder: flatbuffers.Builder, numElems: number): void;
+    static addVectorOfLongs(builder: flatbuffers.Builder, vectorOfLongsOffset: flatbuffers.Offset): void;
+    static createVectorOfLongsVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset;
+    static startVectorOfLongsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addVectorOfDoubles(builder: flatbuffers.Builder, vectorOfDoublesOffset: flatbuffers.Offset): void;
+    static createVectorOfDoublesVector(builder: flatbuffers.Builder, data: number[] | Float64Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createVectorOfDoublesVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startVectorOfDoublesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addParentNamespaceTest(builder: flatbuffers.Builder, parentNamespaceTestOffset: flatbuffers.Offset): void;
+    static addVectorOfReferrables(builder: flatbuffers.Builder, vectorOfReferrablesOffset: flatbuffers.Offset): void;
+    static createVectorOfReferrablesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startVectorOfReferrablesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addSingleWeakReference(builder: flatbuffers.Builder, singleWeakReference: bigint): void;
+    static addVectorOfWeakReferences(builder: flatbuffers.Builder, vectorOfWeakReferencesOffset: flatbuffers.Offset): void;
+    static createVectorOfWeakReferencesVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset;
+    static startVectorOfWeakReferencesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addVectorOfStrongReferrables(builder: flatbuffers.Builder, vectorOfStrongReferrablesOffset: flatbuffers.Offset): void;
+    static createVectorOfStrongReferrablesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startVectorOfStrongReferrablesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addCoOwningReference(builder: flatbuffers.Builder, coOwningReference: bigint): void;
+    static addVectorOfCoOwningReferences(builder: flatbuffers.Builder, vectorOfCoOwningReferencesOffset: flatbuffers.Offset): void;
+    static createVectorOfCoOwningReferencesVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset;
+    static startVectorOfCoOwningReferencesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addNonOwningReference(builder: flatbuffers.Builder, nonOwningReference: bigint): void;
+    static addVectorOfNonOwningReferences(builder: flatbuffers.Builder, vectorOfNonOwningReferencesOffset: flatbuffers.Offset): void;
+    static createVectorOfNonOwningReferencesVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset;
+    static startVectorOfNonOwningReferencesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addAnyUniqueType(builder: flatbuffers.Builder, anyUniqueType: AnyUniqueAliases): void;
+    static addAnyUnique(builder: flatbuffers.Builder, anyUniqueOffset: flatbuffers.Offset): void;
+    static addAnyAmbiguousType(builder: flatbuffers.Builder, anyAmbiguousType: AnyAmbiguousAliases): void;
+    static addAnyAmbiguous(builder: flatbuffers.Builder, anyAmbiguousOffset: flatbuffers.Offset): void;
+    static addVectorOfEnums(builder: flatbuffers.Builder, vectorOfEnumsOffset: flatbuffers.Offset): void;
+    static createVectorOfEnumsVector(builder: flatbuffers.Builder, data: Color[]): flatbuffers.Offset;
+    static startVectorOfEnumsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addSignedEnum(builder: flatbuffers.Builder, signedEnum: Race): void;
+    static addTestrequirednestedflatbuffer(builder: flatbuffers.Builder, testrequirednestedflatbufferOffset: flatbuffers.Offset): void;
+    static createTestrequirednestedflatbufferVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startTestrequirednestedflatbufferVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addScalarKeySortedTables(builder: flatbuffers.Builder, scalarKeySortedTablesOffset: flatbuffers.Offset): void;
+    static createScalarKeySortedTablesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startScalarKeySortedTablesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addNativeInline(builder: flatbuffers.Builder, nativeInlineOffset: flatbuffers.Offset): void;
+    static addLongEnumNonEnumDefault(builder: flatbuffers.Builder, longEnumNonEnumDefault: bigint): void;
+    static addLongEnumNormalDefault(builder: flatbuffers.Builder, longEnumNormalDefault: bigint): void;
+    static addNanDefault(builder: flatbuffers.Builder, nanDefault: number): void;
+    static addInfDefault(builder: flatbuffers.Builder, infDefault: number): void;
+    static addPositiveInfDefault(builder: flatbuffers.Builder, positiveInfDefault: number): void;
+    static addInfinityDefault(builder: flatbuffers.Builder, infinityDefault: number): void;
+    static addPositiveInfinityDefault(builder: flatbuffers.Builder, positiveInfinityDefault: number): void;
+    static addNegativeInfDefault(builder: flatbuffers.Builder, negativeInfDefault: number): void;
+    static addNegativeInfinityDefault(builder: flatbuffers.Builder, negativeInfinityDefault: number): void;
+    static addDoubleInfDefault(builder: flatbuffers.Builder, doubleInfDefault: number): void;
+    static endMonster(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static finishMonsterBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+    static finishSizePrefixedMonsterBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): Monster;
+    unpack(): MonsterT;
+    unpackTo(_o: MonsterT): void;
+}
+export declare class MonsterT implements flatbuffers.IGeneratedObject {
+    pos: Vec3T | null;
+    mana: number;
+    hp: number;
+    name: string | Uint8Array | null;
+    inventory: (number)[];
+    color: Color;
+    testType: Any;
+    test: MonsterT | MyGame_Example2_MonsterT | TestSimpleTableWithEnumT | null;
+    test4: (TestT)[];
+    testarrayofstring: (string)[];
+    testarrayoftables: (MonsterT)[];
+    enemy: MonsterT | null;
+    testnestedflatbuffer: (number)[];
+    testempty: StatT | null;
+    testbool: boolean;
+    testhashs32Fnv1: number;
+    testhashu32Fnv1: number;
+    testhashs64Fnv1: bigint;
+    testhashu64Fnv1: bigint;
+    testhashs32Fnv1a: number;
+    testhashu32Fnv1a: number;
+    testhashs64Fnv1a: bigint;
+    testhashu64Fnv1a: bigint;
+    testarrayofbools: (boolean)[];
+    testf: number;
+    testf2: number;
+    testf3: number;
+    testarrayofstring2: (string)[];
+    testarrayofsortedstruct: (AbilityT)[];
+    flex: (number)[];
+    test5: (TestT)[];
+    vectorOfLongs: (bigint)[];
+    vectorOfDoubles: (number)[];
+    parentNamespaceTest: InParentNamespaceT | null;
+    vectorOfReferrables: (ReferrableT)[];
+    singleWeakReference: bigint;
+    vectorOfWeakReferences: (bigint)[];
+    vectorOfStrongReferrables: (ReferrableT)[];
+    coOwningReference: bigint;
+    vectorOfCoOwningReferences: (bigint)[];
+    nonOwningReference: bigint;
+    vectorOfNonOwningReferences: (bigint)[];
+    anyUniqueType: AnyUniqueAliases;
+    anyUnique: MonsterT | MyGame_Example2_MonsterT | TestSimpleTableWithEnumT | null;
+    anyAmbiguousType: AnyAmbiguousAliases;
+    anyAmbiguous: MonsterT | null;
+    vectorOfEnums: (Color)[];
+    signedEnum: Race;
+    testrequirednestedflatbuffer: (number)[];
+    scalarKeySortedTables: (StatT)[];
+    nativeInline: TestT | null;
+    longEnumNonEnumDefault: bigint;
+    longEnumNormalDefault: bigint;
+    nanDefault: number;
+    infDefault: number;
+    positiveInfDefault: number;
+    infinityDefault: number;
+    positiveInfinityDefault: number;
+    negativeInfDefault: number;
+    negativeInfinityDefault: number;
+    doubleInfDefault: number;
+    constructor(pos?: Vec3T | null, mana?: number, hp?: number, name?: string | Uint8Array | null, inventory?: (number)[], color?: Color, testType?: Any, test?: MonsterT | MyGame_Example2_MonsterT | TestSimpleTableWithEnumT | null, test4?: (TestT)[], testarrayofstring?: (string)[], testarrayoftables?: (MonsterT)[], enemy?: MonsterT | null, testnestedflatbuffer?: (number)[], testempty?: StatT | null, testbool?: boolean, testhashs32Fnv1?: number, testhashu32Fnv1?: number, testhashs64Fnv1?: bigint, testhashu64Fnv1?: bigint, testhashs32Fnv1a?: number, testhashu32Fnv1a?: number, testhashs64Fnv1a?: bigint, testhashu64Fnv1a?: bigint, testarrayofbools?: (boolean)[], testf?: number, testf2?: number, testf3?: number, testarrayofstring2?: (string)[], testarrayofsortedstruct?: (AbilityT)[], flex?: (number)[], test5?: (TestT)[], vectorOfLongs?: (bigint)[], vectorOfDoubles?: (number)[], parentNamespaceTest?: InParentNamespaceT | null, vectorOfReferrables?: (ReferrableT)[], singleWeakReference?: bigint, vectorOfWeakReferences?: (bigint)[], vectorOfStrongReferrables?: (ReferrableT)[], coOwningReference?: bigint, vectorOfCoOwningReferences?: (bigint)[], nonOwningReference?: bigint, vectorOfNonOwningReferences?: (bigint)[], anyUniqueType?: AnyUniqueAliases, anyUnique?: MonsterT | MyGame_Example2_MonsterT | TestSimpleTableWithEnumT | null, anyAmbiguousType?: AnyAmbiguousAliases, anyAmbiguous?: MonsterT | null, vectorOfEnums?: (Color)[], signedEnum?: Race, testrequirednestedflatbuffer?: (number)[], scalarKeySortedTables?: (StatT)[], nativeInline?: TestT | null, longEnumNonEnumDefault?: bigint, longEnumNormalDefault?: bigint, nanDefault?: number, infDefault?: number, positiveInfDefault?: number, infinityDefault?: number, positiveInfinityDefault?: number, negativeInfDefault?: number, negativeInfinityDefault?: number, doubleInfDefault?: number);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/race.d.ts

@@ -0,0 +1,6 @@
+export declare enum Race {
+    None = -1,
+    Human = 0,
+    Dwarf = 1,
+    Elf = 2
+}

third_party/flatbuffers/tests/ts/my-game/example/race.js

@@ -0,0 +1,9 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var Race;
+(function (Race) {
+    Race[Race["None"] = -1] = "None";
+    Race[Race["Human"] = 0] = "Human";
+    Race[Race["Dwarf"] = 1] = "Dwarf";
+    Race[Race["Elf"] = 2] = "Elf";
+})(Race || (Race = {}));

third_party/flatbuffers/tests/ts/my-game/example/race.ts

@@ -0,0 +1,10 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+export enum Race {
+  None = -1,
+  Human = 0,
+  Dwarf = 1,
+  Elf = 2
+}

third_party/flatbuffers/tests/ts/my-game/example/referrable.d.ts

@@ -0,0 +1,24 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class Referrable implements flatbuffers.IUnpackableObject<ReferrableT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Referrable;
+    static getRootAsReferrable(bb: flatbuffers.ByteBuffer, obj?: Referrable): Referrable;
+    static getSizePrefixedRootAsReferrable(bb: flatbuffers.ByteBuffer, obj?: Referrable): Referrable;
+    id(): bigint;
+    mutate_id(value: bigint): boolean;
+    static getFullyQualifiedName(): string;
+    static startReferrable(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, id: bigint): void;
+    static endReferrable(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createReferrable(builder: flatbuffers.Builder, id: bigint): flatbuffers.Offset;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): Referrable;
+    unpack(): ReferrableT;
+    unpackTo(_o: ReferrableT): void;
+}
+export declare class ReferrableT implements flatbuffers.IGeneratedObject {
+    id: bigint;
+    constructor(id?: bigint);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/referrable.js

@@ -0,0 +1,71 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class Referrable {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsReferrable(bb, obj) {
+        return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsReferrable(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    id() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt('0');
+    }
+    mutate_id(value) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint64(this.bb_pos + offset, value);
+        return true;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.Referrable';
+    }
+    static startReferrable(builder) {
+        builder.startObject(1);
+    }
+    static addId(builder, id) {
+        builder.addFieldInt64(0, id, BigInt('0'));
+    }
+    static endReferrable(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createReferrable(builder, id) {
+        Referrable.startReferrable(builder);
+        Referrable.addId(builder, id);
+        return Referrable.endReferrable(builder);
+    }
+    serialize() {
+        return this.bb.bytes();
+    }
+    static deserialize(buffer) {
+        return Referrable.getRootAsReferrable(new flatbuffers.ByteBuffer(buffer));
+    }
+    unpack() {
+        return new ReferrableT(this.id());
+    }
+    unpackTo(_o) {
+        _o.id = this.id();
+    }
+}
+export class ReferrableT {
+    constructor(id = BigInt('0')) {
+        this.id = id;
+    }
+    pack(builder) {
+        return Referrable.createReferrable(builder, this.id);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/referrable.ts

@@ -0,0 +1,97 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class Referrable implements flatbuffers.IUnpackableObject<ReferrableT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Referrable {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsReferrable(bb:flatbuffers.ByteBuffer, obj?:Referrable):Referrable {
+  return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsReferrable(bb:flatbuffers.ByteBuffer, obj?:Referrable):Referrable {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+id():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0');
+}
+
+mutate_id(value:bigint):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint64(this.bb_pos + offset, value);
+  return true;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.Referrable';
+}
+
+static startReferrable(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addId(builder:flatbuffers.Builder, id:bigint) {
+  builder.addFieldInt64(0, id, BigInt('0'));
+}
+
+static endReferrable(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createReferrable(builder:flatbuffers.Builder, id:bigint):flatbuffers.Offset {
+  Referrable.startReferrable(builder);
+  Referrable.addId(builder, id);
+  return Referrable.endReferrable(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Referrable {
+  return Referrable.getRootAsReferrable(new flatbuffers.ByteBuffer(buffer))
+}
+
+unpack(): ReferrableT {
+  return new ReferrableT(
+    this.id()
+  );
+}
+
+
+unpackTo(_o: ReferrableT): void {
+  _o.id = this.id();
+}
+}
+
+export class ReferrableT implements flatbuffers.IGeneratedObject {
+constructor(
+  public id: bigint = BigInt('0')
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return Referrable.createReferrable(builder,
+    this.id
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/stat.d.ts

@@ -0,0 +1,32 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class Stat implements flatbuffers.IUnpackableObject<StatT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Stat;
+    static getRootAsStat(bb: flatbuffers.ByteBuffer, obj?: Stat): Stat;
+    static getSizePrefixedRootAsStat(bb: flatbuffers.ByteBuffer, obj?: Stat): Stat;
+    id(): string | null;
+    id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    val(): bigint;
+    mutate_val(value: bigint): boolean;
+    count(): number;
+    mutate_count(value: number): boolean;
+    static getFullyQualifiedName(): string;
+    static startStat(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addVal(builder: flatbuffers.Builder, val: bigint): void;
+    static addCount(builder: flatbuffers.Builder, count: number): void;
+    static endStat(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createStat(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset, val: bigint, count: number): flatbuffers.Offset;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): Stat;
+    unpack(): StatT;
+    unpackTo(_o: StatT): void;
+}
+export declare class StatT implements flatbuffers.IGeneratedObject {
+    id: string | Uint8Array | null;
+    val: bigint;
+    count: number;
+    constructor(id?: string | Uint8Array | null, val?: bigint, count?: number);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/stat.js

@@ -0,0 +1,100 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class Stat {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsStat(bb, obj) {
+        return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsStat(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    id(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    val() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt('0');
+    }
+    mutate_val(value) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeInt64(this.bb_pos + offset, value);
+        return true;
+    }
+    count() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
+    }
+    mutate_count(value) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint16(this.bb_pos + offset, value);
+        return true;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.Stat';
+    }
+    static startStat(builder) {
+        builder.startObject(3);
+    }
+    static addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    }
+    static addVal(builder, val) {
+        builder.addFieldInt64(1, val, BigInt('0'));
+    }
+    static addCount(builder, count) {
+        builder.addFieldInt16(2, count, 0);
+    }
+    static endStat(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createStat(builder, idOffset, val, count) {
+        Stat.startStat(builder);
+        Stat.addId(builder, idOffset);
+        Stat.addVal(builder, val);
+        Stat.addCount(builder, count);
+        return Stat.endStat(builder);
+    }
+    serialize() {
+        return this.bb.bytes();
+    }
+    static deserialize(buffer) {
+        return Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer));
+    }
+    unpack() {
+        return new StatT(this.id(), this.val(), this.count());
+    }
+    unpackTo(_o) {
+        _o.id = this.id();
+        _o.val = this.val();
+        _o.count = this.count();
+    }
+}
+export class StatT {
+    constructor(id = null, val = BigInt('0'), count = 0) {
+        this.id = id;
+        this.val = val;
+        this.count = count;
+    }
+    pack(builder) {
+        const id = (this.id !== null ? builder.createString(this.id) : 0);
+        return Stat.createStat(builder, id, this.val, this.count);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/stat.ts

@@ -0,0 +1,140 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class Stat implements flatbuffers.IUnpackableObject<StatT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Stat {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat {
+  return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+id():string|null
+id(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+id(optionalEncoding?:any):string|Uint8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+}
+
+val():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');
+}
+
+mutate_val(value:bigint):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeInt64(this.bb_pos + offset, value);
+  return true;
+}
+
+count():number {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+  return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
+}
+
+mutate_count(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint16(this.bb_pos + offset, value);
+  return true;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.Stat';
+}
+
+static startStat(builder:flatbuffers.Builder) {
+  builder.startObject(3);
+}
+
+static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(0, idOffset, 0);
+}
+
+static addVal(builder:flatbuffers.Builder, val:bigint) {
+  builder.addFieldInt64(1, val, BigInt('0'));
+}
+
+static addCount(builder:flatbuffers.Builder, count:number) {
+  builder.addFieldInt16(2, count, 0);
+}
+
+static endStat(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createStat(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset, val:bigint, count:number):flatbuffers.Offset {
+  Stat.startStat(builder);
+  Stat.addId(builder, idOffset);
+  Stat.addVal(builder, val);
+  Stat.addCount(builder, count);
+  return Stat.endStat(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Stat {
+  return Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer))
+}
+
+unpack(): StatT {
+  return new StatT(
+    this.id(),
+    this.val(),
+    this.count()
+  );
+}
+
+
+unpackTo(_o: StatT): void {
+  _o.id = this.id();
+  _o.val = this.val();
+  _o.count = this.count();
+}
+}
+
+export class StatT implements flatbuffers.IGeneratedObject {
+constructor(
+  public id: string|Uint8Array|null = null,
+  public val: bigint = BigInt('0'),
+  public count: number = 0
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  const id = (this.id !== null ? builder.createString(this.id!) : 0);
+
+  return Stat.createStat(builder,
+    id,
+    this.val,
+    this.count
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs-of-structs.d.ts

@@ -0,0 +1,18 @@
+import * as flatbuffers from 'flatbuffers';
+import { StructOfStructs, StructOfStructsT } from '../../my-game/example/struct-of-structs.js';
+export declare class StructOfStructsOfStructs implements flatbuffers.IUnpackableObject<StructOfStructsOfStructsT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StructOfStructsOfStructs;
+    a(obj?: StructOfStructs): StructOfStructs | null;
+    static getFullyQualifiedName(): string;
+    static sizeOf(): number;
+    static createStructOfStructsOfStructs(builder: flatbuffers.Builder, a_a_id: number, a_a_distance: number, a_b_a: number, a_b_b: number, a_c_id: number, a_c_distance: number): flatbuffers.Offset;
+    unpack(): StructOfStructsOfStructsT;
+    unpackTo(_o: StructOfStructsOfStructsT): void;
+}
+export declare class StructOfStructsOfStructsT implements flatbuffers.IGeneratedObject {
+    a: StructOfStructsT | null;
+    constructor(a?: StructOfStructsT | null);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs-of-structs.js

@@ -0,0 +1,51 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+import { StructOfStructs } from '../../my-game/example/struct-of-structs.js';
+export class StructOfStructsOfStructs {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    a(obj) {
+        return (obj || new StructOfStructs()).__init(this.bb_pos, this.bb);
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.StructOfStructsOfStructs';
+    }
+    static sizeOf() {
+        return 20;
+    }
+    static createStructOfStructsOfStructs(builder, a_a_id, a_a_distance, a_b_a, a_b_b, a_c_id, a_c_distance) {
+        builder.prep(4, 20);
+        builder.prep(4, 20);
+        builder.prep(4, 8);
+        builder.writeInt32(a_c_distance);
+        builder.writeInt32(a_c_id);
+        builder.prep(2, 4);
+        builder.pad(1);
+        builder.writeInt8(a_b_b);
+        builder.writeInt16(a_b_a);
+        builder.prep(4, 8);
+        builder.writeInt32(a_a_distance);
+        builder.writeInt32(a_a_id);
+        return builder.offset();
+    }
+    unpack() {
+        return new StructOfStructsOfStructsT((this.a() !== null ? this.a().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.a = (this.a() !== null ? this.a().unpack() : null);
+    }
+}
+export class StructOfStructsOfStructsT {
+    constructor(a = null) {
+        this.a = a;
+    }
+    pack(builder) {
+        return StructOfStructsOfStructs.createStructOfStructsOfStructs(builder, (this.a?.a?.id ?? 0), (this.a?.a?.distance ?? 0), (this.a?.b?.a ?? 0), (this.a?.b?.b ?? 0), (this.a?.c?.id ?? 0), (this.a?.c?.distance ?? 0));
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs-of-structs.ts

@@ -0,0 +1,76 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+import { StructOfStructs, StructOfStructsT } from '../../my-game/example/struct-of-structs.js';
+
+
+export class StructOfStructsOfStructs implements flatbuffers.IUnpackableObject<StructOfStructsOfStructsT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):StructOfStructsOfStructs {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+a(obj?:StructOfStructs):StructOfStructs|null {
+  return (obj || new StructOfStructs()).__init(this.bb_pos, this.bb!);
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.StructOfStructsOfStructs';
+}
+
+static sizeOf():number {
+  return 20;
+}
+
+static createStructOfStructsOfStructs(builder:flatbuffers.Builder, a_a_id: number, a_a_distance: number, a_b_a: number, a_b_b: number, a_c_id: number, a_c_distance: number):flatbuffers.Offset {
+  builder.prep(4, 20);
+  builder.prep(4, 20);
+  builder.prep(4, 8);
+  builder.writeInt32(a_c_distance);
+  builder.writeInt32(a_c_id);
+  builder.prep(2, 4);
+  builder.pad(1);
+  builder.writeInt8(a_b_b);
+  builder.writeInt16(a_b_a);
+  builder.prep(4, 8);
+  builder.writeInt32(a_a_distance);
+  builder.writeInt32(a_a_id);
+  return builder.offset();
+}
+
+
+unpack(): StructOfStructsOfStructsT {
+  return new StructOfStructsOfStructsT(
+    (this.a() !== null ? this.a()!.unpack() : null)
+  );
+}
+
+
+unpackTo(_o: StructOfStructsOfStructsT): void {
+  _o.a = (this.a() !== null ? this.a()!.unpack() : null);
+}
+}
+
+export class StructOfStructsOfStructsT implements flatbuffers.IGeneratedObject {
+constructor(
+  public a: StructOfStructsT|null = null
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return StructOfStructsOfStructs.createStructOfStructsOfStructs(builder,
+    (this.a?.a?.id ?? 0),
+    (this.a?.a?.distance ?? 0),
+    (this.a?.b?.a ?? 0),
+    (this.a?.b?.b ?? 0),
+    (this.a?.c?.id ?? 0),
+    (this.a?.c?.distance ?? 0)
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs.d.ts

@@ -0,0 +1,23 @@
+import * as flatbuffers from 'flatbuffers';
+import { Ability, AbilityT } from '../../my-game/example/ability.js';
+import { Test, TestT } from '../../my-game/example/test.js';
+export declare class StructOfStructs implements flatbuffers.IUnpackableObject<StructOfStructsT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StructOfStructs;
+    a(obj?: Ability): Ability | null;
+    b(obj?: Test): Test | null;
+    c(obj?: Ability): Ability | null;
+    static getFullyQualifiedName(): string;
+    static sizeOf(): number;
+    static createStructOfStructs(builder: flatbuffers.Builder, a_id: number, a_distance: number, b_a: number, b_b: number, c_id: number, c_distance: number): flatbuffers.Offset;
+    unpack(): StructOfStructsT;
+    unpackTo(_o: StructOfStructsT): void;
+}
+export declare class StructOfStructsT implements flatbuffers.IGeneratedObject {
+    a: AbilityT | null;
+    b: TestT | null;
+    c: AbilityT | null;
+    constructor(a?: AbilityT | null, b?: TestT | null, c?: AbilityT | null);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs.js

@@ -0,0 +1,61 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+import { Ability } from '../../my-game/example/ability.js';
+import { Test } from '../../my-game/example/test.js';
+export class StructOfStructs {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    a(obj) {
+        return (obj || new Ability()).__init(this.bb_pos, this.bb);
+    }
+    b(obj) {
+        return (obj || new Test()).__init(this.bb_pos + 8, this.bb);
+    }
+    c(obj) {
+        return (obj || new Ability()).__init(this.bb_pos + 12, this.bb);
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.StructOfStructs';
+    }
+    static sizeOf() {
+        return 20;
+    }
+    static createStructOfStructs(builder, a_id, a_distance, b_a, b_b, c_id, c_distance) {
+        builder.prep(4, 20);
+        builder.prep(4, 8);
+        builder.writeInt32(c_distance);
+        builder.writeInt32(c_id);
+        builder.prep(2, 4);
+        builder.pad(1);
+        builder.writeInt8(b_b);
+        builder.writeInt16(b_a);
+        builder.prep(4, 8);
+        builder.writeInt32(a_distance);
+        builder.writeInt32(a_id);
+        return builder.offset();
+    }
+    unpack() {
+        return new StructOfStructsT((this.a() !== null ? this.a().unpack() : null), (this.b() !== null ? this.b().unpack() : null), (this.c() !== null ? this.c().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.a = (this.a() !== null ? this.a().unpack() : null);
+        _o.b = (this.b() !== null ? this.b().unpack() : null);
+        _o.c = (this.c() !== null ? this.c().unpack() : null);
+    }
+}
+export class StructOfStructsT {
+    constructor(a = null, b = null, c = null) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+    pack(builder) {
+        return StructOfStructs.createStructOfStructs(builder, (this.a?.id ?? 0), (this.a?.distance ?? 0), (this.b?.a ?? 0), (this.b?.b ?? 0), (this.c?.id ?? 0), (this.c?.distance ?? 0));
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/struct-of-structs.ts

@@ -0,0 +1,90 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+import { Ability, AbilityT } from '../../my-game/example/ability.js';
+import { Test, TestT } from '../../my-game/example/test.js';
+
+
+export class StructOfStructs implements flatbuffers.IUnpackableObject<StructOfStructsT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):StructOfStructs {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+a(obj?:Ability):Ability|null {
+  return (obj || new Ability()).__init(this.bb_pos, this.bb!);
+}
+
+b(obj?:Test):Test|null {
+  return (obj || new Test()).__init(this.bb_pos + 8, this.bb!);
+}
+
+c(obj?:Ability):Ability|null {
+  return (obj || new Ability()).__init(this.bb_pos + 12, this.bb!);
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.StructOfStructs';
+}
+
+static sizeOf():number {
+  return 20;
+}
+
+static createStructOfStructs(builder:flatbuffers.Builder, a_id: number, a_distance: number, b_a: number, b_b: number, c_id: number, c_distance: number):flatbuffers.Offset {
+  builder.prep(4, 20);
+  builder.prep(4, 8);
+  builder.writeInt32(c_distance);
+  builder.writeInt32(c_id);
+  builder.prep(2, 4);
+  builder.pad(1);
+  builder.writeInt8(b_b);
+  builder.writeInt16(b_a);
+  builder.prep(4, 8);
+  builder.writeInt32(a_distance);
+  builder.writeInt32(a_id);
+  return builder.offset();
+}
+
+
+unpack(): StructOfStructsT {
+  return new StructOfStructsT(
+    (this.a() !== null ? this.a()!.unpack() : null),
+    (this.b() !== null ? this.b()!.unpack() : null),
+    (this.c() !== null ? this.c()!.unpack() : null)
+  );
+}
+
+
+unpackTo(_o: StructOfStructsT): void {
+  _o.a = (this.a() !== null ? this.a()!.unpack() : null);
+  _o.b = (this.b() !== null ? this.b()!.unpack() : null);
+  _o.c = (this.c() !== null ? this.c()!.unpack() : null);
+}
+}
+
+export class StructOfStructsT implements flatbuffers.IGeneratedObject {
+constructor(
+  public a: AbilityT|null = null,
+  public b: TestT|null = null,
+  public c: AbilityT|null = null
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return StructOfStructs.createStructOfStructs(builder,
+    (this.a?.id ?? 0),
+    (this.a?.distance ?? 0),
+    (this.b?.a ?? 0),
+    (this.b?.b ?? 0),
+    (this.c?.id ?? 0),
+    (this.c?.distance ?? 0)
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/test-simple-table-with-enum.d.ts

@@ -0,0 +1,25 @@
+import * as flatbuffers from 'flatbuffers';
+import { Color } from '../../my-game/example/color.js';
+export declare class TestSimpleTableWithEnum implements flatbuffers.IUnpackableObject<TestSimpleTableWithEnumT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): TestSimpleTableWithEnum;
+    static getRootAsTestSimpleTableWithEnum(bb: flatbuffers.ByteBuffer, obj?: TestSimpleTableWithEnum): TestSimpleTableWithEnum;
+    static getSizePrefixedRootAsTestSimpleTableWithEnum(bb: flatbuffers.ByteBuffer, obj?: TestSimpleTableWithEnum): TestSimpleTableWithEnum;
+    color(): Color;
+    mutate_color(value: Color): boolean;
+    static getFullyQualifiedName(): string;
+    static startTestSimpleTableWithEnum(builder: flatbuffers.Builder): void;
+    static addColor(builder: flatbuffers.Builder, color: Color): void;
+    static endTestSimpleTableWithEnum(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createTestSimpleTableWithEnum(builder: flatbuffers.Builder, color: Color): flatbuffers.Offset;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): TestSimpleTableWithEnum;
+    unpack(): TestSimpleTableWithEnumT;
+    unpackTo(_o: TestSimpleTableWithEnumT): void;
+}
+export declare class TestSimpleTableWithEnumT implements flatbuffers.IGeneratedObject {
+    color: Color;
+    constructor(color?: Color);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/test-simple-table-with-enum.js

@@ -0,0 +1,72 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { Color } from '../../my-game/example/color.js';
+export class TestSimpleTableWithEnum {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsTestSimpleTableWithEnum(bb, obj) {
+        return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsTestSimpleTableWithEnum(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    color() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : Color.Green;
+    }
+    mutate_color(value) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint8(this.bb_pos + offset, value);
+        return true;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.TestSimpleTableWithEnum';
+    }
+    static startTestSimpleTableWithEnum(builder) {
+        builder.startObject(1);
+    }
+    static addColor(builder, color) {
+        builder.addFieldInt8(0, color, Color.Green);
+    }
+    static endTestSimpleTableWithEnum(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createTestSimpleTableWithEnum(builder, color) {
+        TestSimpleTableWithEnum.startTestSimpleTableWithEnum(builder);
+        TestSimpleTableWithEnum.addColor(builder, color);
+        return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
+    }
+    serialize() {
+        return this.bb.bytes();
+    }
+    static deserialize(buffer) {
+        return TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum(new flatbuffers.ByteBuffer(buffer));
+    }
+    unpack() {
+        return new TestSimpleTableWithEnumT(this.color());
+    }
+    unpackTo(_o) {
+        _o.color = this.color();
+    }
+}
+export class TestSimpleTableWithEnumT {
+    constructor(color = Color.Green) {
+        this.color = color;
+    }
+    pack(builder) {
+        return TestSimpleTableWithEnum.createTestSimpleTableWithEnum(builder, this.color);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/test-simple-table-with-enum.ts

@@ -0,0 +1,98 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+import { Color } from '../../my-game/example/color.js';
+
+
+export class TestSimpleTableWithEnum implements flatbuffers.IUnpackableObject<TestSimpleTableWithEnumT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):TestSimpleTableWithEnum {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimpleTableWithEnum):TestSimpleTableWithEnum {
+  return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimpleTableWithEnum):TestSimpleTableWithEnum {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+color():Color {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : Color.Green;
+}
+
+mutate_color(value:Color):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint8(this.bb_pos + offset, value);
+  return true;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.TestSimpleTableWithEnum';
+}
+
+static startTestSimpleTableWithEnum(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addColor(builder:flatbuffers.Builder, color:Color) {
+  builder.addFieldInt8(0, color, Color.Green);
+}
+
+static endTestSimpleTableWithEnum(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createTestSimpleTableWithEnum(builder:flatbuffers.Builder, color:Color):flatbuffers.Offset {
+  TestSimpleTableWithEnum.startTestSimpleTableWithEnum(builder);
+  TestSimpleTableWithEnum.addColor(builder, color);
+  return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):TestSimpleTableWithEnum {
+  return TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum(new flatbuffers.ByteBuffer(buffer))
+}
+
+unpack(): TestSimpleTableWithEnumT {
+  return new TestSimpleTableWithEnumT(
+    this.color()
+  );
+}
+
+
+unpackTo(_o: TestSimpleTableWithEnumT): void {
+  _o.color = this.color();
+}
+}
+
+export class TestSimpleTableWithEnumT implements flatbuffers.IGeneratedObject {
+constructor(
+  public color: Color = Color.Green
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return TestSimpleTableWithEnum.createTestSimpleTableWithEnum(builder,
+    this.color
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/test.d.ts

@@ -0,0 +1,21 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class Test implements flatbuffers.IUnpackableObject<TestT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Test;
+    a(): number;
+    mutate_a(value: number): boolean;
+    b(): number;
+    mutate_b(value: number): boolean;
+    static getFullyQualifiedName(): string;
+    static sizeOf(): number;
+    static createTest(builder: flatbuffers.Builder, a: number, b: number): flatbuffers.Offset;
+    unpack(): TestT;
+    unpackTo(_o: TestT): void;
+}
+export declare class TestT implements flatbuffers.IGeneratedObject {
+    a: number;
+    b: number;
+    constructor(a?: number, b?: number);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/test.js

@@ -0,0 +1,55 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+export class Test {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    a() {
+        return this.bb.readInt16(this.bb_pos);
+    }
+    mutate_a(value) {
+        this.bb.writeInt16(this.bb_pos + 0, value);
+        return true;
+    }
+    b() {
+        return this.bb.readInt8(this.bb_pos + 2);
+    }
+    mutate_b(value) {
+        this.bb.writeInt8(this.bb_pos + 2, value);
+        return true;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.Test';
+    }
+    static sizeOf() {
+        return 4;
+    }
+    static createTest(builder, a, b) {
+        builder.prep(2, 4);
+        builder.pad(1);
+        builder.writeInt8(b);
+        builder.writeInt16(a);
+        return builder.offset();
+    }
+    unpack() {
+        return new TestT(this.a(), this.b());
+    }
+    unpackTo(_o) {
+        _o.a = this.a();
+        _o.b = this.b();
+    }
+}
+export class TestT {
+    constructor(a = 0, b = 0) {
+        this.a = a;
+        this.b = b;
+    }
+    pack(builder) {
+        return Test.createTest(builder, this.a, this.b);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/test.ts

@@ -0,0 +1,80 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class Test implements flatbuffers.IUnpackableObject<TestT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Test {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+a():number {
+  return this.bb!.readInt16(this.bb_pos);
+}
+
+mutate_a(value:number):boolean {
+  this.bb!.writeInt16(this.bb_pos + 0, value);
+  return true;
+}
+
+b():number {
+  return this.bb!.readInt8(this.bb_pos + 2);
+}
+
+mutate_b(value:number):boolean {
+  this.bb!.writeInt8(this.bb_pos + 2, value);
+  return true;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.Test';
+}
+
+static sizeOf():number {
+  return 4;
+}
+
+static createTest(builder:flatbuffers.Builder, a: number, b: number):flatbuffers.Offset {
+  builder.prep(2, 4);
+  builder.pad(1);
+  builder.writeInt8(b);
+  builder.writeInt16(a);
+  return builder.offset();
+}
+
+
+unpack(): TestT {
+  return new TestT(
+    this.a(),
+    this.b()
+  );
+}
+
+
+unpackTo(_o: TestT): void {
+  _o.a = this.a();
+  _o.b = this.b();
+}
+}
+
+export class TestT implements flatbuffers.IGeneratedObject {
+constructor(
+  public a: number = 0,
+  public b: number = 0
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return Test.createTest(builder,
+    this.a,
+    this.b
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/type-aliases.d.ts

@@ -0,0 +1,82 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class TypeAliases implements flatbuffers.IUnpackableObject<TypeAliasesT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): TypeAliases;
+    static getRootAsTypeAliases(bb: flatbuffers.ByteBuffer, obj?: TypeAliases): TypeAliases;
+    static getSizePrefixedRootAsTypeAliases(bb: flatbuffers.ByteBuffer, obj?: TypeAliases): TypeAliases;
+    i8(): number;
+    mutate_i8(value: number): boolean;
+    u8(): number;
+    mutate_u8(value: number): boolean;
+    i16(): number;
+    mutate_i16(value: number): boolean;
+    u16(): number;
+    mutate_u16(value: number): boolean;
+    i32(): number;
+    mutate_i32(value: number): boolean;
+    u32(): number;
+    mutate_u32(value: number): boolean;
+    i64(): bigint;
+    mutate_i64(value: bigint): boolean;
+    u64(): bigint;
+    mutate_u64(value: bigint): boolean;
+    f32(): number;
+    mutate_f32(value: number): boolean;
+    f64(): number;
+    mutate_f64(value: number): boolean;
+    v8(index: number): number | null;
+    v8Length(): number;
+    v8Array(): Int8Array | null;
+    vf64(index: number): number | null;
+    vf64Length(): number;
+    vf64Array(): Float64Array | null;
+    static getFullyQualifiedName(): string;
+    static startTypeAliases(builder: flatbuffers.Builder): void;
+    static addI8(builder: flatbuffers.Builder, i8: number): void;
+    static addU8(builder: flatbuffers.Builder, u8: number): void;
+    static addI16(builder: flatbuffers.Builder, i16: number): void;
+    static addU16(builder: flatbuffers.Builder, u16: number): void;
+    static addI32(builder: flatbuffers.Builder, i32: number): void;
+    static addU32(builder: flatbuffers.Builder, u32: number): void;
+    static addI64(builder: flatbuffers.Builder, i64: bigint): void;
+    static addU64(builder: flatbuffers.Builder, u64: bigint): void;
+    static addF32(builder: flatbuffers.Builder, f32: number): void;
+    static addF64(builder: flatbuffers.Builder, f64: number): void;
+    static addV8(builder: flatbuffers.Builder, v8Offset: flatbuffers.Offset): void;
+    static createV8Vector(builder: flatbuffers.Builder, data: number[] | Int8Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createV8Vector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startV8Vector(builder: flatbuffers.Builder, numElems: number): void;
+    static addVf64(builder: flatbuffers.Builder, vf64Offset: flatbuffers.Offset): void;
+    static createVf64Vector(builder: flatbuffers.Builder, data: number[] | Float64Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createVf64Vector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startVf64Vector(builder: flatbuffers.Builder, numElems: number): void;
+    static endTypeAliases(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createTypeAliases(builder: flatbuffers.Builder, i8: number, u8: number, i16: number, u16: number, i32: number, u32: number, i64: bigint, u64: bigint, f32: number, f64: number, v8Offset: flatbuffers.Offset, vf64Offset: flatbuffers.Offset): flatbuffers.Offset;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): TypeAliases;
+    unpack(): TypeAliasesT;
+    unpackTo(_o: TypeAliasesT): void;
+}
+export declare class TypeAliasesT implements flatbuffers.IGeneratedObject {
+    i8: number;
+    u8: number;
+    i16: number;
+    u16: number;
+    i32: number;
+    u32: number;
+    i64: bigint;
+    u64: bigint;
+    f32: number;
+    f64: number;
+    v8: (number)[];
+    vf64: (number)[];
+    constructor(i8?: number, u8?: number, i16?: number, u16?: number, i32?: number, u32?: number, i64?: bigint, u64?: bigint, f32?: number, f64?: number, v8?: (number)[], vf64?: (number)[]);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/type-aliases.js

@@ -0,0 +1,291 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class TypeAliases {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsTypeAliases(bb, obj) {
+        return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsTypeAliases(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    i8() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt8(this.bb_pos + offset) : 0;
+    }
+    mutate_i8(value) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeInt8(this.bb_pos + offset, value);
+        return true;
+    }
+    u8() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : 0;
+    }
+    mutate_u8(value) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint8(this.bb_pos + offset, value);
+        return true;
+    }
+    i16() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt16(this.bb_pos + offset) : 0;
+    }
+    mutate_i16(value) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeInt16(this.bb_pos + offset, value);
+        return true;
+    }
+    u16() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
+    }
+    mutate_u16(value) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint16(this.bb_pos + offset, value);
+        return true;
+    }
+    i32() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    }
+    mutate_i32(value) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeInt32(this.bb_pos + offset, value);
+        return true;
+    }
+    u32() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+    }
+    mutate_u32(value) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint32(this.bb_pos + offset, value);
+        return true;
+    }
+    i64() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt('0');
+    }
+    mutate_i64(value) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeInt64(this.bb_pos + offset, value);
+        return true;
+    }
+    u64() {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt('0');
+    }
+    mutate_u64(value) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeUint64(this.bb_pos + offset, value);
+        return true;
+    }
+    f32() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    mutate_f32(value) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    f64() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    mutate_f64(value) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat64(this.bb_pos + offset, value);
+        return true;
+    }
+    v8(index) {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    v8Length() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    v8Array() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    vf64(index) {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+    }
+    vf64Length() {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    vf64Array() {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.TypeAliases';
+    }
+    static startTypeAliases(builder) {
+        builder.startObject(12);
+    }
+    static addI8(builder, i8) {
+        builder.addFieldInt8(0, i8, 0);
+    }
+    static addU8(builder, u8) {
+        builder.addFieldInt8(1, u8, 0);
+    }
+    static addI16(builder, i16) {
+        builder.addFieldInt16(2, i16, 0);
+    }
+    static addU16(builder, u16) {
+        builder.addFieldInt16(3, u16, 0);
+    }
+    static addI32(builder, i32) {
+        builder.addFieldInt32(4, i32, 0);
+    }
+    static addU32(builder, u32) {
+        builder.addFieldInt32(5, u32, 0);
+    }
+    static addI64(builder, i64) {
+        builder.addFieldInt64(6, i64, BigInt('0'));
+    }
+    static addU64(builder, u64) {
+        builder.addFieldInt64(7, u64, BigInt('0'));
+    }
+    static addF32(builder, f32) {
+        builder.addFieldFloat32(8, f32, 0.0);
+    }
+    static addF64(builder, f64) {
+        builder.addFieldFloat64(9, f64, 0.0);
+    }
+    static addV8(builder, v8Offset) {
+        builder.addFieldOffset(10, v8Offset, 0);
+    }
+    static createV8Vector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startV8Vector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    }
+    static addVf64(builder, vf64Offset) {
+        builder.addFieldOffset(11, vf64Offset, 0);
+    }
+    static createVf64Vector(builder, data) {
+        builder.startVector(8, data.length, 8);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addFloat64(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startVf64Vector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+    }
+    static endTypeAliases(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createTypeAliases(builder, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, v8Offset, vf64Offset) {
+        TypeAliases.startTypeAliases(builder);
+        TypeAliases.addI8(builder, i8);
+        TypeAliases.addU8(builder, u8);
+        TypeAliases.addI16(builder, i16);
+        TypeAliases.addU16(builder, u16);
+        TypeAliases.addI32(builder, i32);
+        TypeAliases.addU32(builder, u32);
+        TypeAliases.addI64(builder, i64);
+        TypeAliases.addU64(builder, u64);
+        TypeAliases.addF32(builder, f32);
+        TypeAliases.addF64(builder, f64);
+        TypeAliases.addV8(builder, v8Offset);
+        TypeAliases.addVf64(builder, vf64Offset);
+        return TypeAliases.endTypeAliases(builder);
+    }
+    serialize() {
+        return this.bb.bytes();
+    }
+    static deserialize(buffer) {
+        return TypeAliases.getRootAsTypeAliases(new flatbuffers.ByteBuffer(buffer));
+    }
+    unpack() {
+        return new TypeAliasesT(this.i8(), this.u8(), this.i16(), this.u16(), this.i32(), this.u32(), this.i64(), this.u64(), this.f32(), this.f64(), this.bb.createScalarList(this.v8.bind(this), this.v8Length()), this.bb.createScalarList(this.vf64.bind(this), this.vf64Length()));
+    }
+    unpackTo(_o) {
+        _o.i8 = this.i8();
+        _o.u8 = this.u8();
+        _o.i16 = this.i16();
+        _o.u16 = this.u16();
+        _o.i32 = this.i32();
+        _o.u32 = this.u32();
+        _o.i64 = this.i64();
+        _o.u64 = this.u64();
+        _o.f32 = this.f32();
+        _o.f64 = this.f64();
+        _o.v8 = this.bb.createScalarList(this.v8.bind(this), this.v8Length());
+        _o.vf64 = this.bb.createScalarList(this.vf64.bind(this), this.vf64Length());
+    }
+}
+export class TypeAliasesT {
+    constructor(i8 = 0, u8 = 0, i16 = 0, u16 = 0, i32 = 0, u32 = 0, i64 = BigInt('0'), u64 = BigInt('0'), f32 = 0.0, f64 = 0.0, v8 = [], vf64 = []) {
+        this.i8 = i8;
+        this.u8 = u8;
+        this.i16 = i16;
+        this.u16 = u16;
+        this.i32 = i32;
+        this.u32 = u32;
+        this.i64 = i64;
+        this.u64 = u64;
+        this.f32 = f32;
+        this.f64 = f64;
+        this.v8 = v8;
+        this.vf64 = vf64;
+    }
+    pack(builder) {
+        const v8 = TypeAliases.createV8Vector(builder, this.v8);
+        const vf64 = TypeAliases.createVf64Vector(builder, this.vf64);
+        return TypeAliases.createTypeAliases(builder, this.i8, this.u8, this.i16, this.u16, this.i32, this.u32, this.i64, this.u64, this.f32, this.f64, v8, vf64);
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/type-aliases.ts

@@ -0,0 +1,407 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class TypeAliases implements flatbuffers.IUnpackableObject<TypeAliasesT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):TypeAliases {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAliases {
+  return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAliases {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+i8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0;
+}
+
+mutate_i8(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeInt8(this.bb_pos + offset, value);
+  return true;
+}
+
+u8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0;
+}
+
+mutate_u8(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint8(this.bb_pos + offset, value);
+  return true;
+}
+
+i16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+  return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
+}
+
+mutate_i16(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeInt16(this.bb_pos + offset, value);
+  return true;
+}
+
+u16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 10);
+  return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
+}
+
+mutate_u16(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 10);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint16(this.bb_pos + offset, value);
+  return true;
+}
+
+i32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 12);
+  return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
+}
+
+mutate_i32(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 12);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeInt32(this.bb_pos + offset, value);
+  return true;
+}
+
+u32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 14);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+mutate_u32(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 14);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint32(this.bb_pos + offset, value);
+  return true;
+}
+
+i64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 16);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');
+}
+
+mutate_i64(value:bigint):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 16);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeInt64(this.bb_pos + offset, value);
+  return true;
+}
+
+u64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 18);
+  return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0');
+}
+
+mutate_u64(value:bigint):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 18);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint64(this.bb_pos + offset, value);
+  return true;
+}
+
+f32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 20);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0;
+}
+
+mutate_f32(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 20);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+f64():number {
+  const offset = this.bb!.__offset(this.bb_pos, 22);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;
+}
+
+mutate_f64(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 22);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat64(this.bb_pos + offset, value);
+  return true;
+}
+
+v8(index: number):number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 24);
+  return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
+}
+
+v8Length():number {
+  const offset = this.bb!.__offset(this.bb_pos, 24);
+  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+}
+
+v8Array():Int8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 24);
+  return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+}
+
+vf64(index: number):number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 26);
+  return offset ? this.bb!.readFloat64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : 0;
+}
+
+vf64Length():number {
+  const offset = this.bb!.__offset(this.bb_pos, 26);
+  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+}
+
+vf64Array():Float64Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 26);
+  return offset ? new Float64Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.TypeAliases';
+}
+
+static startTypeAliases(builder:flatbuffers.Builder) {
+  builder.startObject(12);
+}
+
+static addI8(builder:flatbuffers.Builder, i8:number) {
+  builder.addFieldInt8(0, i8, 0);
+}
+
+static addU8(builder:flatbuffers.Builder, u8:number) {
+  builder.addFieldInt8(1, u8, 0);
+}
+
+static addI16(builder:flatbuffers.Builder, i16:number) {
+  builder.addFieldInt16(2, i16, 0);
+}
+
+static addU16(builder:flatbuffers.Builder, u16:number) {
+  builder.addFieldInt16(3, u16, 0);
+}
+
+static addI32(builder:flatbuffers.Builder, i32:number) {
+  builder.addFieldInt32(4, i32, 0);
+}
+
+static addU32(builder:flatbuffers.Builder, u32:number) {
+  builder.addFieldInt32(5, u32, 0);
+}
+
+static addI64(builder:flatbuffers.Builder, i64:bigint) {
+  builder.addFieldInt64(6, i64, BigInt('0'));
+}
+
+static addU64(builder:flatbuffers.Builder, u64:bigint) {
+  builder.addFieldInt64(7, u64, BigInt('0'));
+}
+
+static addF32(builder:flatbuffers.Builder, f32:number) {
+  builder.addFieldFloat32(8, f32, 0.0);
+}
+
+static addF64(builder:flatbuffers.Builder, f64:number) {
+  builder.addFieldFloat64(9, f64, 0.0);
+}
+
+static addV8(builder:flatbuffers.Builder, v8Offset:flatbuffers.Offset) {
+  builder.addFieldOffset(10, v8Offset, 0);
+}
+
+static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array):flatbuffers.Offset;
+/**
+ * @deprecated This Uint8Array overload will be removed in the future.
+ */
+static createV8Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
+static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array|Uint8Array):flatbuffers.Offset {
+  builder.startVector(1, data.length, 1);
+  for (let i = data.length - 1; i >= 0; i--) {
+    builder.addInt8(data[i]!);
+  }
+  return builder.endVector();
+}
+
+static startV8Vector(builder:flatbuffers.Builder, numElems:number) {
+  builder.startVector(1, numElems, 1);
+}
+
+static addVf64(builder:flatbuffers.Builder, vf64Offset:flatbuffers.Offset) {
+  builder.addFieldOffset(11, vf64Offset, 0);
+}
+
+static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset;
+/**
+ * @deprecated This Uint8Array overload will be removed in the future.
+ */
+static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
+static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array|Uint8Array):flatbuffers.Offset {
+  builder.startVector(8, data.length, 8);
+  for (let i = data.length - 1; i >= 0; i--) {
+    builder.addFloat64(data[i]!);
+  }
+  return builder.endVector();
+}
+
+static startVf64Vector(builder:flatbuffers.Builder, numElems:number) {
+  builder.startVector(8, numElems, 8);
+}
+
+static endTypeAliases(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createTypeAliases(builder:flatbuffers.Builder, i8:number, u8:number, i16:number, u16:number, i32:number, u32:number, i64:bigint, u64:bigint, f32:number, f64:number, v8Offset:flatbuffers.Offset, vf64Offset:flatbuffers.Offset):flatbuffers.Offset {
+  TypeAliases.startTypeAliases(builder);
+  TypeAliases.addI8(builder, i8);
+  TypeAliases.addU8(builder, u8);
+  TypeAliases.addI16(builder, i16);
+  TypeAliases.addU16(builder, u16);
+  TypeAliases.addI32(builder, i32);
+  TypeAliases.addU32(builder, u32);
+  TypeAliases.addI64(builder, i64);
+  TypeAliases.addU64(builder, u64);
+  TypeAliases.addF32(builder, f32);
+  TypeAliases.addF64(builder, f64);
+  TypeAliases.addV8(builder, v8Offset);
+  TypeAliases.addVf64(builder, vf64Offset);
+  return TypeAliases.endTypeAliases(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):TypeAliases {
+  return TypeAliases.getRootAsTypeAliases(new flatbuffers.ByteBuffer(buffer))
+}
+
+unpack(): TypeAliasesT {
+  return new TypeAliasesT(
+    this.i8(),
+    this.u8(),
+    this.i16(),
+    this.u16(),
+    this.i32(),
+    this.u32(),
+    this.i64(),
+    this.u64(),
+    this.f32(),
+    this.f64(),
+    this.bb!.createScalarList<number>(this.v8.bind(this), this.v8Length()),
+    this.bb!.createScalarList<number>(this.vf64.bind(this), this.vf64Length())
+  );
+}
+
+
+unpackTo(_o: TypeAliasesT): void {
+  _o.i8 = this.i8();
+  _o.u8 = this.u8();
+  _o.i16 = this.i16();
+  _o.u16 = this.u16();
+  _o.i32 = this.i32();
+  _o.u32 = this.u32();
+  _o.i64 = this.i64();
+  _o.u64 = this.u64();
+  _o.f32 = this.f32();
+  _o.f64 = this.f64();
+  _o.v8 = this.bb!.createScalarList<number>(this.v8.bind(this), this.v8Length());
+  _o.vf64 = this.bb!.createScalarList<number>(this.vf64.bind(this), this.vf64Length());
+}
+}
+
+export class TypeAliasesT implements flatbuffers.IGeneratedObject {
+constructor(
+  public i8: number = 0,
+  public u8: number = 0,
+  public i16: number = 0,
+  public u16: number = 0,
+  public i32: number = 0,
+  public u32: number = 0,
+  public i64: bigint = BigInt('0'),
+  public u64: bigint = BigInt('0'),
+  public f32: number = 0.0,
+  public f64: number = 0.0,
+  public v8: (number)[] = [],
+  public vf64: (number)[] = []
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  const v8 = TypeAliases.createV8Vector(builder, this.v8);
+  const vf64 = TypeAliases.createVf64Vector(builder, this.vf64);
+
+  return TypeAliases.createTypeAliases(builder,
+    this.i8,
+    this.u8,
+    this.i16,
+    this.u16,
+    this.i32,
+    this.u32,
+    this.i64,
+    this.u64,
+    this.f32,
+    this.f64,
+    v8,
+    vf64
+  );
+}
+}

third_party/flatbuffers/tests/ts/my-game/example/vec3.d.ts

@@ -0,0 +1,34 @@
+import * as flatbuffers from 'flatbuffers';
+import { Color } from '../../my-game/example/color.js';
+import { Test, TestT } from '../../my-game/example/test.js';
+export declare class Vec3 implements flatbuffers.IUnpackableObject<Vec3T> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Vec3;
+    x(): number;
+    mutate_x(value: number): boolean;
+    y(): number;
+    mutate_y(value: number): boolean;
+    z(): number;
+    mutate_z(value: number): boolean;
+    test1(): number;
+    mutate_test1(value: number): boolean;
+    test2(): Color;
+    mutate_test2(value: Color): boolean;
+    test3(obj?: Test): Test | null;
+    static getFullyQualifiedName(): string;
+    static sizeOf(): number;
+    static createVec3(builder: flatbuffers.Builder, x: number, y: number, z: number, test1: number, test2: Color, test3_a: number, test3_b: number): flatbuffers.Offset;
+    unpack(): Vec3T;
+    unpackTo(_o: Vec3T): void;
+}
+export declare class Vec3T implements flatbuffers.IGeneratedObject {
+    x: number;
+    y: number;
+    z: number;
+    test1: number;
+    test2: Color;
+    test3: TestT | null;
+    constructor(x?: number, y?: number, z?: number, test1?: number, test2?: Color, test3?: TestT | null);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

third_party/flatbuffers/tests/ts/my-game/example/vec3.js

@@ -0,0 +1,98 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+import { Color } from '../../my-game/example/color.js';
+import { Test } from '../../my-game/example/test.js';
+export class Vec3 {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    x() {
+        return this.bb.readFloat32(this.bb_pos);
+    }
+    mutate_x(value) {
+        this.bb.writeFloat32(this.bb_pos + 0, value);
+        return true;
+    }
+    y() {
+        return this.bb.readFloat32(this.bb_pos + 4);
+    }
+    mutate_y(value) {
+        this.bb.writeFloat32(this.bb_pos + 4, value);
+        return true;
+    }
+    z() {
+        return this.bb.readFloat32(this.bb_pos + 8);
+    }
+    mutate_z(value) {
+        this.bb.writeFloat32(this.bb_pos + 8, value);
+        return true;
+    }
+    test1() {
+        return this.bb.readFloat64(this.bb_pos + 16);
+    }
+    mutate_test1(value) {
+        this.bb.writeFloat64(this.bb_pos + 16, value);
+        return true;
+    }
+    test2() {
+        return this.bb.readUint8(this.bb_pos + 24);
+    }
+    mutate_test2(value) {
+        this.bb.writeUint8(this.bb_pos + 24, value);
+        return true;
+    }
+    test3(obj) {
+        return (obj || new Test()).__init(this.bb_pos + 26, this.bb);
+    }
+    static getFullyQualifiedName() {
+        return 'MyGame.Example.Vec3';
+    }
+    static sizeOf() {
+        return 32;
+    }
+    static createVec3(builder, x, y, z, test1, test2, test3_a, test3_b) {
+        builder.prep(8, 32);
+        builder.pad(2);
+        builder.prep(2, 4);
+        builder.pad(1);
+        builder.writeInt8(test3_b);
+        builder.writeInt16(test3_a);
+        builder.pad(1);
+        builder.writeInt8(test2);
+        builder.writeFloat64(test1);
+        builder.pad(4);
+        builder.writeFloat32(z);
+        builder.writeFloat32(y);
+        builder.writeFloat32(x);
+        return builder.offset();
+    }
+    unpack() {
+        return new Vec3T(this.x(), this.y(), this.z(), this.test1(), this.test2(), (this.test3() !== null ? this.test3().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.x = this.x();
+        _o.y = this.y();
+        _o.z = this.z();
+        _o.test1 = this.test1();
+        _o.test2 = this.test2();
+        _o.test3 = (this.test3() !== null ? this.test3().unpack() : null);
+    }
+}
+export class Vec3T {
+    constructor(x = 0.0, y = 0.0, z = 0.0, test1 = 0.0, test2 = Color.Red, test3 = null) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.test1 = test1;
+        this.test2 = test2;
+        this.test3 = test3;
+    }
+    pack(builder) {
+        return Vec3.createVec3(builder, this.x, this.y, this.z, this.test1, this.test2, (this.test3?.a ?? 0), (this.test3?.b ?? 0));
+    }
+}

third_party/flatbuffers/tests/ts/my-game/example/vec3.ts

@@ -0,0 +1,139 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+import { Color } from '../../my-game/example/color.js';
+import { Test, TestT } from '../../my-game/example/test.js';
+
+
+export class Vec3 implements flatbuffers.IUnpackableObject<Vec3T> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Vec3 {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+x():number {
+  return this.bb!.readFloat32(this.bb_pos);
+}
+
+mutate_x(value:number):boolean {
+  this.bb!.writeFloat32(this.bb_pos + 0, value);
+  return true;
+}
+
+y():number {
+  return this.bb!.readFloat32(this.bb_pos + 4);
+}
+
+mutate_y(value:number):boolean {
+  this.bb!.writeFloat32(this.bb_pos + 4, value);
+  return true;
+}
+
+z():number {
+  return this.bb!.readFloat32(this.bb_pos + 8);
+}
+
+mutate_z(value:number):boolean {
+  this.bb!.writeFloat32(this.bb_pos + 8, value);
+  return true;
+}
+
+test1():number {
+  return this.bb!.readFloat64(this.bb_pos + 16);
+}
+
+mutate_test1(value:number):boolean {
+  this.bb!.writeFloat64(this.bb_pos + 16, value);
+  return true;
+}
+
+test2():Color {
+  return this.bb!.readUint8(this.bb_pos + 24);
+}
+
+mutate_test2(value:Color):boolean {
+  this.bb!.writeUint8(this.bb_pos + 24, value);
+  return true;
+}
+
+test3(obj?:Test):Test|null {
+  return (obj || new Test()).__init(this.bb_pos + 26, this.bb!);
+}
+
+static getFullyQualifiedName():string {
+  return 'MyGame.Example.Vec3';
+}
+
+static sizeOf():number {
+  return 32;
+}
+
+static createVec3(builder:flatbuffers.Builder, x: number, y: number, z: number, test1: number, test2: Color, test3_a: number, test3_b: number):flatbuffers.Offset {
+  builder.prep(8, 32);
+  builder.pad(2);
+  builder.prep(2, 4);
+  builder.pad(1);
+  builder.writeInt8(test3_b);
+  builder.writeInt16(test3_a);
+  builder.pad(1);
+  builder.writeInt8(test2);
+  builder.writeFloat64(test1);
+  builder.pad(4);
+  builder.writeFloat32(z);
+  builder.writeFloat32(y);
+  builder.writeFloat32(x);
+  return builder.offset();
+}
+
+
+unpack(): Vec3T {
+  return new Vec3T(
+    this.x(),
+    this.y(),
+    this.z(),
+    this.test1(),
+    this.test2(),
+    (this.test3() !== null ? this.test3()!.unpack() : null)
+  );
+}
+
+
+unpackTo(_o: Vec3T): void {
+  _o.x = this.x();
+  _o.y = this.y();
+  _o.z = this.z();
+  _o.test1 = this.test1();
+  _o.test2 = this.test2();
+  _o.test3 = (this.test3() !== null ? this.test3()!.unpack() : null);
+}
+}
+
+export class Vec3T implements flatbuffers.IGeneratedObject {
+constructor(
+  public x: number = 0.0,
+  public y: number = 0.0,
+  public z: number = 0.0,
+  public test1: number = 0.0,
+  public test2: Color = Color.Red,
+  public test3: TestT|null = null
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return Vec3.createVec3(builder,
+    this.x,
+    this.y,
+    this.z,
+    this.test1,
+    this.test2,
+    (this.test3?.a ?? 0),
+    (this.test3?.b ?? 0)
+  );
+}
+}