diff --git a/tests/FlatBuffers.Test.Swift/Package.swift b/tests/FlatBuffers.Test.Swift/Package.swift
new file mode 100644
index 0000000..6c17443
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Package.swift
@@ -0,0 +1,22 @@
+// swift-tools-version:5.1
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "FlatBuffers.Test.Swift",
+    platforms: [
+        .iOS(.v11),
+        .macOS(.v10_14),
+    ],
+    dependencies: [
+        .package(path: "../../swift/"),
+        .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.0.0-alpha.19")
+    ],
+    targets: [
+        .target(name: "SwiftFlatBuffers"),
+        .testTarget(
+            name: "FlatBuffers.Test.SwiftTests",
+            dependencies: ["FlatBuffers", "GRPC"]),
+    ]
+)
diff --git a/tests/FlatBuffers.Test.Swift/Sources/SwiftFlatBuffers/main.swift b/tests/FlatBuffers.Test.Swift/Sources/SwiftFlatBuffers/main.swift
new file mode 100644
index 0000000..12bfbb3
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Sources/SwiftFlatBuffers/main.swift
@@ -0,0 +1,2 @@
+import Foundation
+print("Flatbuffers")
diff --git a/tests/FlatBuffers.Test.Swift/SwiftTest.sh b/tests/FlatBuffers.Test.Swift/SwiftTest.sh
new file mode 100755
index 0000000..2779d90
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/SwiftTest.sh
@@ -0,0 +1,10 @@
+swift_dir=`pwd`
+cd ..
+test_dir=`pwd`
+
+cd ${swift_dir}/Tests/FlatBuffers.Test.SwiftTests
+${test_dir}/../flatc --swift --gen-mutable --grpc --gen-object-api -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs
+${test_dir}/../flatc --swift ${test_dir}/optional_scalars.fbs
+cd ${swift_dir}
+swift build --build-tests
+swift test
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
new file mode 100644
index 0000000..dcd0aa9
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
@@ -0,0 +1,282 @@
+import XCTest
+import Foundation
+@testable import FlatBuffers
+
+typealias Test = MyGame_Example_Test
+typealias Monster = MyGame_Example_Monster
+typealias Vec3 = MyGame_Example_Vec3
+typealias Stat = MyGame_Example_Stat
+
+class FlatBuffersMonsterWriterTests: XCTestCase {
+    
+    func testData() {
+        let data = Data([48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+        let _data = ByteBuffer(data: data)
+        readMonster(fb: _data)
+    }
+    
+    func testReadFromOtherLanguages() {
+        let path = FileManager.default.currentDirectoryPath
+        let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent("monsterdata_test").appendingPathExtension("mon")
+        guard let data = try? Data(contentsOf: url) else { return }
+        let _data = ByteBuffer(data: data)
+        readMonster(fb: _data)
+    }
+    
+    func testCreateMonster() {
+        let bytes = createMonster(withPrefix: false)
+        XCTAssertEqual(bytes.sizedByteArray, [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+        readMonster(fb: bytes.buffer)
+        mutateMonster(fb: bytes.buffer)
+        readMonster(fb: bytes.buffer)
+    }
+    
+    func testCreateMonsterResizedBuffer() {
+        let bytes = createMonster(withPrefix: false)
+        XCTAssertEqual(bytes.sizedByteArray, [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+        readMonster(fb: bytes.sizedBuffer)
+    }
+    
+    func testCreateMonsterPrefixed() {
+        let bytes = createMonster(withPrefix: true)
+        XCTAssertEqual(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+        
+        let newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes.buffer)
+        readMonster(fb: newBuf)
+    }
+
+    func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
+        var fbb = FlatBufferBuilder(initialSize: 1)
+        let name = fbb.create(string: "Frodo")
+        let mStart = Monster.startMonster(&fbb)
+        Monster.add(name: name, &fbb)
+        let root = Monster.endMonster(&fbb, start: mStart)
+        fbb.finish(offset: root)
+        let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)
+        XCTAssertNil(newMonster.pos)
+        XCTAssertEqual(newMonster.name, "Frodo")
+    }
+
+    func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
+        var fbb = FlatBufferBuilder(initialSize: 1)
+        let name = fbb.create(string: "Barney")
+        let mStart = Monster.startMonster(&fbb)
+        Monster.add(pos: MyGame_Example_Vec3.createVec3(builder: &fbb, x: 10, test2: .blue), &fbb)
+        Monster.add(name: name, &fbb)
+        let root = Monster.endMonster(&fbb, start: mStart)
+        fbb.finish(offset: root)
+        
+        let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)
+        XCTAssertEqual(newMonster.pos!.x, 10)
+        XCTAssertEqual(newMonster.name, "Barney")
+    }
+
+    func testReadMonsterFromUnsafePointerWithoutCopying() {
+        var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]
+        let unpacked = array.withUnsafeMutableBytes { (memory) -> MyGame_Example_MonsterT in
+            let bytes = ByteBuffer(assumingMemoryBound: memory.baseAddress!, capacity: memory.count)
+            var monster = Monster.getRootAsMonster(bb: bytes)
+            readFlatbufferMonster(monster: &monster)
+            let unpacked = monster.unpack()
+            return unpacked
+        }
+        readObjectApi(monster: unpacked)
+    }
+    
+    func readMonster(fb: ByteBuffer) {
+        var monster = Monster.getRootAsMonster(bb: fb)
+        readFlatbufferMonster(monster: &monster)
+        let unpacked: MyGame_Example_MonsterT? = monster.unpack()
+        readObjectApi(monster: unpacked!)
+        guard let buffer = unpacked?.serialize() else { fatalError("Couldnt generate bytebuffer") }
+        var newMonster = Monster.getRootAsMonster(bb: buffer)
+        readFlatbufferMonster(monster: &newMonster)
+    }
+    
+    func createMonster(withPrefix prefix: Bool) -> FlatBufferBuilder {
+        var fbb = FlatBufferBuilder(initialSize: 1)
+        let names = [fbb.create(string: "Frodo"), fbb.create(string: "Barney"), fbb.create(string: "Wilma")]
+        var offsets: [Offset<UOffset>] = []
+        let start1 = Monster.startMonster(&fbb)
+        Monster.add(name: names[0], &fbb)
+        offsets.append(Monster.endMonster(&fbb, start: start1))
+        let start2 = Monster.startMonster(&fbb)
+        Monster.add(name: names[1], &fbb)
+        offsets.append(Monster.endMonster(&fbb, start: start2))
+        let start3 = Monster.startMonster(&fbb)
+        Monster.add(name: names[2], &fbb)
+        offsets.append(Monster.endMonster(&fbb, start: start3))
+        
+        let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb)
+        
+        let str = fbb.create(string: "MyMonster")
+        let test1 = fbb.create(string: "test1")
+        let test2 = fbb.create(string: "test2")
+        let _inv: [Byte] = [0, 1, 2, 3, 4]
+        let inv = fbb.createVector(_inv)
+        
+        let fred = fbb.create(string: "Fred")
+        let mon1Start = Monster.startMonster(&fbb)
+        Monster.add(name: fred, &fbb)
+        let mon2 = Monster.endMonster(&fbb, start: mon1Start)
+        
+        let size = 2
+        Monster.startVectorOfTest4(size, in: &fbb)
+        MyGame_Example_Test.createTest(builder: &fbb, a: 10, b: 20)
+        MyGame_Example_Test.createTest(builder: &fbb, a: 30, b: 40)
+        let test4 = fbb.endVectorOfStructs(count: size)
+        
+        let stringTestVector = fbb.createVector(ofOffsets: [test1, test2])
+        let mStart = Monster.startMonster(&fbb)
+        let posStruct = MyGame_Example_Vec3.createVec3(builder: &fbb, x: 1, y: 2, z: 3, test1: 3, test2: .green, test3a: 5, test3b: 6)
+        Monster.add(pos: posStruct, &fbb)
+        Monster.add(hp: 80, &fbb)
+        Monster.add(name: str, &fbb)
+        Monster.addVectorOf(inventory: inv, &fbb)
+        Monster.add(testType: .monster, &fbb)
+        Monster.add(test: mon2, &fbb)
+        Monster.addVectorOf(test4: test4, &fbb)
+        Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb)
+        Monster.add(testbool: true, &fbb)
+        Monster.addVectorOf(testarrayoftables: sortedArray, &fbb)
+        let end = Monster.endMonster(&fbb, start: mStart)
+        Monster.finish(&fbb, end: end, prefix: prefix)
+        return fbb
+    }
+    
+    func mutateMonster(fb: ByteBuffer) {
+        let monster = Monster.getRootAsMonster(bb: fb)
+        XCTAssertFalse(monster.mutate(mana: 10))
+        XCTAssertEqual(monster.testarrayoftables(at: 0)?.name, "Barney")
+        XCTAssertEqual(monster.testarrayoftables(at: 1)?.name, "Frodo")
+        XCTAssertEqual(monster.testarrayoftables(at: 2)?.name, "Wilma")
+        
+        // Example of searching for a table by the key
+        XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
+        XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
+        XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
+        
+        XCTAssertEqual(monster.testType, .monster)
+        
+        XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)
+        XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)
+        XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)
+        XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)
+        XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)
+        
+        for i in 0..<monster.inventoryCount {
+            XCTAssertEqual(monster.inventory(at: i), Byte(i + 1))
+        }
+        
+        XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)
+        XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)
+        XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)
+        XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
+        XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
+        
+        let vec = monster.pos
+        XCTAssertEqual(vec?.x, 1)
+        XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
+        XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
+        XCTAssertEqual(vec?.x, 55.0)
+        XCTAssertEqual(vec?.test1, 55.0)
+        XCTAssertTrue(vec?.mutate(x: 1) ?? false)
+        XCTAssertEqual(vec?.x, 1)
+        XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
+    }
+    
+    func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
+        XCTAssertEqual(monster.hp, 80)
+        XCTAssertEqual(monster.mana, 150)
+        XCTAssertEqual(monster.name, "MyMonster")
+        let pos = monster.pos
+        XCTAssertEqual(pos?.x, 1)
+        XCTAssertEqual(pos?.y, 2)
+        XCTAssertEqual(pos?.z, 3)
+        XCTAssertEqual(pos?.test1, 3)
+        XCTAssertEqual(pos?.test2, .green)
+        let test = pos?.test3
+        XCTAssertEqual(test?.a, 5)
+        XCTAssertEqual(test?.b, 6)
+        XCTAssertEqual(monster.testType, .monster)
+        let monster2 = monster.test(type: Monster.self)
+        XCTAssertEqual(monster2?.name, "Fred")
+        
+        XCTAssertEqual(monster.mutate(mana: 10), false)
+        
+        XCTAssertEqual(monster.mana, 150)
+        XCTAssertEqual(monster.inventoryCount, 5)
+        var sum: Byte = 0
+        for i in 0...monster.inventoryCount {
+            sum += monster.inventory(at: i)
+        }
+        XCTAssertEqual(sum, 10)
+        XCTAssertEqual(monster.test4Count, 2)
+        let test0 = monster.test4(at: 0)
+        let test1 = monster.test4(at: 1)
+        var sum0 = 0
+        var sum1 = 0
+        if let a = test0?.a, let b = test0?.b {
+            sum0 = Int(a) + Int(b)
+        }
+        if let a = test1?.a, let b = test1?.b {
+            sum1 = Int(a) + Int(b)
+        }
+        XCTAssertEqual(sum0 + sum1, 100)
+        XCTAssertEqual(monster.testarrayofstringCount, 2)
+        XCTAssertEqual(monster.testarrayofstring(at: 0), "test1")
+        XCTAssertEqual(monster.testarrayofstring(at: 1), "test2")
+        XCTAssertEqual(monster.testbool, true)
+        
+        let array = monster.nameSegmentArray
+        XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
+        
+        if 0 == monster.testarrayofboolsCount  {
+            XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
+        } else {
+            XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
+        }
+    }
+    
+    func readObjectApi(monster: MyGame_Example_MonsterT) {
+        XCTAssertEqual(monster.hp, 80)
+        XCTAssertEqual(monster.mana, 150)
+        XCTAssertEqual(monster.name, "MyMonster")
+        let pos = monster.pos
+        XCTAssertEqual(pos?.x, 1)
+        XCTAssertEqual(pos?.y, 2)
+        XCTAssertEqual(pos?.z, 3)
+        XCTAssertEqual(pos?.test1, 3)
+        XCTAssertEqual(pos?.test2, .green)
+        let test = pos?.test3
+        XCTAssertEqual(test?.a, 5)
+        XCTAssertEqual(test?.b, 6)
+        let monster2 = monster.test?.value as? MyGame_Example_MonsterT
+        XCTAssertEqual(monster2?.name, "Fred")
+        XCTAssertEqual(monster.mana, 150)
+        monster.mana = 10
+        XCTAssertEqual(monster.mana, 10)
+        monster.mana = 150
+        XCTAssertEqual(monster.mana, 150)
+        
+        XCTAssertEqual(monster.inventory.count, 5)
+        var sum: Byte = 0
+        for i in monster.inventory {
+            sum += i
+        }
+        XCTAssertEqual(sum, 10)
+        XCTAssertEqual(monster.test4.count, 2)
+        let test0 = monster.test4[0]
+        let test1 = monster.test4[1]
+        var sum0 = 0
+        var sum1 = 0
+        if let a = test0?.a, let b = test0?.b {
+            sum0 = Int(a) + Int(b)
+        }
+        if let a = test1?.a, let b = test1?.b {
+            sum1 = Int(a) + Int(b)
+        }
+        XCTAssertEqual(sum0 + sum1, 100)
+        XCTAssertEqual(monster.testbool, true)
+    }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift
new file mode 100644
index 0000000..b19813f
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift
@@ -0,0 +1,43 @@
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersStructsTests: XCTestCase {
+
+    func testWritingAndMutatingBools() {
+        var fbb = FlatBufferBuilder()
+        let start = TestMutatingBool.startTestMutatingBool(&fbb)
+        TestMutatingBool.add(b: createProperty(builder: &fbb), &fbb)
+        let root = TestMutatingBool.endTestMutatingBool(&fbb, start: start)
+        fbb.finish(offset: root)
+        
+        let testMutatingBool = TestMutatingBool.getRootAsTestMutatingBool(bb: fbb.sizedBuffer)
+        let property = testMutatingBool.b
+        XCTAssertEqual(property?.property, false)
+        property?.mutate(property: false)
+        XCTAssertEqual(property?.property, false)
+        property?.mutate(property: true)
+        XCTAssertEqual(property?.property, true)
+    }
+    
+}
+
+struct Vec: Readable {
+    var __buffer: ByteBuffer! { __p.bb }
+
+    static var size = 12
+    static var alignment = 4
+    private var __p: Struct
+    init(_ fb: ByteBuffer, o: Int32) { __p = Struct(bb: fb, position: o) }
+    var x: Float32 { return __p.readBuffer(of: Float32.self, at: 0)}
+    var y: Float32 { return __p.readBuffer(of: Float32.self, at: 4)}
+    var z: Float32 { return __p.readBuffer(of: Float32.self, at: 8)}
+}
+
+@discardableResult
+func createVecWrite(builder: inout FlatBufferBuilder, x: Float32, y: Float32, z: Float32) -> Offset<UOffset> {
+    builder.createStructOf(size: Vec.size, alignment: Vec.alignment)
+    builder.reverseAdd(v: x, postion: 0)
+    builder.reverseAdd(v: y, postion: 4)
+    builder.reverseAdd(v: z, postion: 8)
+    return builder.endStruct()
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
new file mode 100644
index 0000000..cac1740
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
@@ -0,0 +1,141 @@
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersTests: XCTestCase {
+    
+    let country = "Norway"
+    
+    func testEndian() { XCTAssertEqual(isLitteEndian, true) }
+    
+    func testOffset() {
+        let o = Offset<Int>()
+        let b = Offset<Int>(offset: 1)
+        XCTAssertEqual(o.isEmpty, true)
+        XCTAssertEqual(b.isEmpty, false)
+    }
+    
+    func testCreateString() {
+        let helloWorld = "Hello, world!"
+        var b = FlatBufferBuilder(initialSize: 16)
+        XCTAssertEqual(b.create(string: country).o, 12)
+        XCTAssertEqual(b.create(string: helloWorld).o, 32)
+        b.clear()
+        XCTAssertEqual(b.create(string: helloWorld).o, 20)
+        XCTAssertEqual(b.create(string: country).o, 32)
+        b.clear()
+        XCTAssertEqual(b.create(string: String(repeating: "a", count: 257)).o, 264)
+    }
+    
+    func testStartTable() {
+        var b = FlatBufferBuilder(initialSize: 16)
+        XCTAssertNoThrow(b.startTable(with: 0))
+        b.clear()
+        XCTAssertEqual(b.create(string: country).o, 12)
+        XCTAssertEqual(b.startTable(with: 0), 12)
+    }
+    
+    func testCreateFinish() {
+        var b = FlatBufferBuilder(initialSize: 16)
+        let countryOff = Country.createCountry(builder: &b, name: country, log: 200, lan: 100)
+        b.finish(offset: countryOff)
+        let v: [UInt8] = [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+        XCTAssertEqual(b.sizedByteArray, v)
+    }
+    
+    func testCreateFinishWithPrefix() {
+        var b = FlatBufferBuilder(initialSize: 16)
+        let countryOff = Country.createCountry(builder: &b, name: country, log: 200, lan: 100)
+        b.finish(offset: countryOff, addPrefix: true)
+        let v: [UInt8] = [44, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+        XCTAssertEqual(b.sizedByteArray, v)
+    }
+    
+    func testReadCountry() {
+        let v: [UInt8] = [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+        let buffer = ByteBuffer(bytes: v)
+        let c = Country.getRootAsCountry(buffer)
+        XCTAssertEqual(c.lan, 100)
+        XCTAssertEqual(c.log, 200)
+        XCTAssertEqual(c.nameVector, [78, 111, 114, 119, 97, 121])
+        XCTAssertEqual(c.name, country)
+    }
+    
+    func testWriteNullableStrings() {
+        var b = FlatBufferBuilder()
+        XCTAssertTrue(b.create(string: nil).isEmpty)
+        XCTAssertTrue(b.createShared(string: nil).isEmpty)
+    }
+    
+    func testWriteOptionalValues() {
+        var b = FlatBufferBuilder()
+        let root = optional_scalars_ScalarStuff.createScalarStuff(&b,
+                                                                  justI8: 80,
+                                                                  maybeI8: nil,
+                                                                  justU8: 100,
+                                                                  maybeU8: 10,
+                                                                  maybeBool: true,
+                                                                  justEnum: .one,
+                                                                  maybeEnum: nil)
+        b.finish(offset: root)
+        let scalarTable = optional_scalars_ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
+        XCTAssertEqual(scalarTable.justI8, 80)
+        XCTAssertNil(scalarTable.maybeI8)
+        XCTAssertEqual(scalarTable.maybeBool, true)
+        XCTAssertEqual(scalarTable.defaultI8, 42)
+        XCTAssertEqual(scalarTable.justU8, 100)
+        XCTAssertEqual(scalarTable.maybeU8, 10)
+        XCTAssertEqual(scalarTable.justEnum, .one)
+        XCTAssertNil(scalarTable.maybeEnum)
+    }
+}
+
+class Country {
+    
+    static let offsets: (name: VOffset, lan: VOffset, lng: VOffset) = (4, 6, 8)
+    private var __t: Table
+    
+    private init(_ t: Table) {
+        __t = t
+    }
+    
+    var lan: Int32 { let o = __t.offset(6); return o == 0 ? 0 : __t.readBuffer(of: Int32.self, at: o) }
+    var log: Int32 { let o = __t.offset(8); return o == 0 ? 0 : __t.readBuffer(of: Int32.self, at: o) }
+    var nameVector: [UInt8]? { return __t.getVector(at: 4) }
+    var name: String? { let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+    
+    @inlinable static func getRootAsCountry(_ bb: ByteBuffer) -> Country {
+        return Country(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    }
+    
+    @inlinable static func createCountry(builder: inout FlatBufferBuilder, name: String, log: Int32, lan: Int32) -> Offset<Country> {
+        return createCountry(builder: &builder, offset: builder.create(string: name), log: log, lan: lan)
+    }
+    
+    @inlinable static func createCountry(builder: inout FlatBufferBuilder, offset: Offset<String>, log: Int32, lan: Int32) -> Offset<Country> {
+        let _start = builder.startTable(with: 3)
+        Country.add(builder: &builder, lng: log)
+        Country.add(builder: &builder, lan: lan)
+        Country.add(builder: &builder, name: offset)
+        return Country.end(builder: &builder, startOffset: _start)
+    }
+    
+    @inlinable static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Country> {
+        return Offset(offset: builder.endTable(at: startOffset))
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, name: String) {
+        add(builder: &builder, name: builder.create(string: name))
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+        builder.add(offset: name, at: Country.offsets.name)
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, lan: Int32) {
+        builder.add(element: lan, def: 0, at: Country.offsets.lan)
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, lng: Int32) {
+        builder.add(element: lng, def: 0, at: Country.offsets.lng)
+    }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
new file mode 100644
index 0000000..a90baae
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
@@ -0,0 +1,242 @@
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersUnionTests: XCTestCase {
+    
+    func testCreateMonstor() {
+        
+        var b = FlatBufferBuilder(initialSize: 20)
+        let dmg: Int16 = 5
+        let str = "Axe"
+        let axe = b.create(string: str)
+        let weapon = Weapon.createWeapon(builder: &b, offset: axe, dmg: dmg)
+        let weapons = b.createVector(ofOffsets: [weapon])
+        let root = LocalMonster.createMonster(builder: &b,
+                                         offset: weapons,
+                                         equipment: .Weapon,
+                                         equippedOffset: weapon.o)
+        b.finish(offset: root)
+        let buffer = b.sizedByteArray
+        XCTAssertEqual(buffer, [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 8, 0, 7, 0, 12, 0, 10, 0, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 12, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, 3, 0, 0, 0, 65, 120, 101, 0])
+        let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer))
+        XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg)
+        XCTAssertEqual(monster.weapon(at: 0)?.name, str)
+        XCTAssertEqual(monster.weapon(at: 0)?.nameVector, [65, 120, 101])
+        let p: Weapon? = monster.equiped()
+        XCTAssertEqual(p?.dmg, dmg)
+        XCTAssertEqual(p?.name, str)
+        XCTAssertEqual(p?.nameVector, [65, 120, 101])
+    }
+    
+    func testEndTableFinish() {
+        var builder = FlatBufferBuilder(initialSize: 20)
+        let sword = builder.create(string: "Sword")
+        let axe = builder.create(string: "Axe")
+        let weaponOne = Weapon.createWeapon(builder: &builder, offset: sword, dmg: 3)
+        let weaponTwo = Weapon.createWeapon(builder: &builder, offset: axe, dmg: 5)
+        let name = builder.create(string: "Orc")
+        let inventory: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        let inv = builder.createVector(inventory, size: 10)
+        let weapons = builder.createVector(ofOffsets: [weaponOne, weaponTwo])
+        builder.startVectorOfStructs(count: 2, size: Vec.size, alignment: Vec.alignment)
+        createVecWrite(builder: &builder, x: 1.0, y: 2.0, z: 3.0)
+        createVecWrite(builder: &builder, x: 4.0, y: 5.0, z: 6.0)
+        let path = builder.endVectorOfStructs(count: 2)
+        let orc = FinalMonster.createMonster(builder: &builder,
+                                             position: createVecWrite(builder: &builder, x: 1.0, y: 2.0, z: 3.0),
+                                             hp: 300,
+                                             name: name,
+                                             inventory: inv,
+                                             color: .red,
+                                             weapons: weapons,
+                                             equipment: .Weapon,
+                                             equippedOffset: weaponTwo,
+                                             path: path)
+        builder.finish(offset: orc)
+        XCTAssertEqual(builder.sizedByteArray, [32, 0, 0, 0, 0, 0, 26, 0, 36, 0, 36, 0, 0, 0, 34, 0, 28, 0, 0, 0, 24, 0, 23, 0, 16, 0, 15, 0, 8, 0, 4, 0, 26, 0, 0, 0, 44, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 76, 0, 0, 0, 0, 0, 44, 1, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 0, 0, 0, 0, 128, 64, 0, 0, 160, 64, 0, 0, 192, 64, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 0, 0, 52, 0, 0, 0, 28, 0, 0, 0, 10, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 3, 0, 0, 0, 79, 114, 99, 0, 244, 255, 255, 255, 0, 0, 5, 0, 24, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 3, 0, 12, 0, 0, 0, 3, 0, 0, 0, 65, 120, 101, 0, 5, 0, 0, 0, 83, 119, 111, 114, 100, 0, 0, 0])
+    }
+    
+    func testEnumVector() {
+        let vectorOfEnums: [ColorsNameSpace.RGB] = [.blue, .green]
+        
+        var builder = FlatBufferBuilder(initialSize: 1)
+        let off = builder.createVector(vectorOfEnums)
+        let start = ColorsNameSpace.Monster.startMonster(&builder)
+        ColorsNameSpace.Monster.add(colors: off, &builder)
+        let end = ColorsNameSpace.Monster.endMonster(&builder, start: start)
+        builder.finish(offset: end)
+        XCTAssertEqual(builder.sizedByteArray, [12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0])
+        let monster = ColorsNameSpace.Monster.getRootAsMonster(bb: builder.buffer)
+        XCTAssertEqual(monster.colorsCount, 2)
+        XCTAssertEqual(monster.colors(at: 0), .blue)
+        XCTAssertEqual(monster.colors(at: 1), .green)
+    }
+    
+    func testUnionVector() {
+        var fb = FlatBufferBuilder()
+        
+        let swordDmg: Int32 = 8
+        let attackStart = Attacker.startAttacker(&fb)
+        Attacker.add(swordAttackDamage: swordDmg, &fb)
+        let attack = Attacker.endAttacker(&fb, start: attackStart)
+        
+        let characterType: [Character] = [.belle, .mulan, .bookfan]
+        
+        let characters = [
+            BookReader.createBookReader(builder: &fb, booksRead: 7),
+            attack,
+            BookReader.createBookReader(builder: &fb, booksRead: 2)
+        ]
+        let types = fb.createVector(characterType)
+        let characterVector = fb.createVector(ofOffsets: characters)
+        let end = Movie.createMovie(&fb, vectorOfCharactersType: types, vectorOfCharacters: characterVector)
+        Movie.finish(&fb, end: end)
+        
+        var movie = Movie.getRootAsMovie(bb: fb.buffer)
+        XCTAssertEqual(movie.charactersTypeCount, Int32(characterType.count))
+        XCTAssertEqual(movie.charactersCount, Int32(characters.count))
+        
+        for i in 0..<movie.charactersTypeCount {
+            XCTAssertEqual(movie.charactersType(at: i), characterType[Int(i)])
+        }
+        
+        XCTAssertEqual(movie.characters(at: 0, type: BookReader.self)?.booksRead, 7)
+        XCTAssertEqual(movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage, swordDmg)
+        XCTAssertEqual(movie.characters(at: 2, type: BookReader.self)?.booksRead, 2)
+        
+        var objc: MovieT? = movie.unpack()
+        XCTAssertEqual(movie.charactersTypeCount, Int32(objc?.characters.count ?? 0))
+        XCTAssertEqual(movie.characters(at: 0, type: BookReader.self)?.booksRead, (objc?.characters[0]?.value as? BookReaderT)?.booksRead)
+        fb.clear()
+        let newMovie = Movie.pack(&fb, obj: &objc)
+        fb.finish(offset: newMovie)
+        
+        let packedMovie = Movie.getRootAsMovie(bb: fb.buffer)
+        
+        XCTAssertEqual(packedMovie.characters(at: 0, type: BookReader.self)?.booksRead, movie.characters(at: 0, type: BookReader.self)?.booksRead)
+        XCTAssertEqual(packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage, movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage)
+        XCTAssertEqual(packedMovie.characters(at: 2, type: BookReader.self)?.booksRead, movie.characters(at: 2, type: BookReader.self)?.booksRead)
+    }
+}
+
+public enum ColorsNameSpace {
+    
+    enum RGB: Int32, Enum {
+        typealias T = Int32
+        static var byteSize: Int { return MemoryLayout<Int32>.size }
+        var value: Int32 { return self.rawValue }
+        case red = 0, green = 1, blue = 2
+    }
+    
+    struct Monster: FlatBufferObject {
+        var __buffer: ByteBuffer! { _accessor.bb }
+        
+        private var _accessor: Table
+        static func getRootAsMonster(bb: ByteBuffer) -> Monster { return Monster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+        
+        init(_ t: Table) { _accessor = t }
+        init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+        
+        public var colorsCount: Int32 { let o = _accessor.offset(4); return o == 0 ? 0 : _accessor.vector(count: o) }
+        public func colors(at index: Int32) -> ColorsNameSpace.RGB? { let o = _accessor.offset(4); return o == 0 ? ColorsNameSpace.RGB(rawValue: 0)! : ColorsNameSpace.RGB(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) }
+        static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+        static func add(colors: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: colors, at: 4)  }
+        static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    }
+}
+
+
+enum Equipment: Byte { case none, Weapon }
+
+enum Color3: Int8 { case red = 0, green, blue }
+
+struct FinalMonster {
+    
+    @inlinable static func createMonster(builder: inout FlatBufferBuilder,
+                                         position: Offset<UOffset>,
+                                         hp: Int16,
+                                         name: Offset<String>,
+                                         inventory: Offset<UOffset>,
+                                         color: Color3,
+                                         weapons: Offset<UOffset>,
+                                         equipment: Equipment = .none,
+                                         equippedOffset: Offset<Weapon>,
+                                         path: Offset<UOffset>) -> Offset<LocalMonster> {
+        let start = builder.startTable(with: 11)
+        builder.add(structOffset: 4)
+        builder.add(element: hp, def: 100, at: 8)
+        builder.add(offset: name, at: 10)
+        builder.add(offset: inventory, at: 14)
+        builder.add(element: color.rawValue, def: Color3.green.rawValue, at: 16)
+        builder.add(offset: weapons, at: 18)
+        builder.add(element: equipment.rawValue, def: Equipment.none.rawValue, at: 20)
+        builder.add(offset: equippedOffset, at: 22)
+        builder.add(offset: path, at: 24)
+        return Offset(offset: builder.endTable(at: start))
+    }
+}
+
+struct LocalMonster {
+    
+    private var __t: Table
+    
+    init(_ fb: ByteBuffer, o: Int32) { __t = Table(bb: fb, position: o) }
+    init(_ t: Table) { __t = t }
+    
+    func weapon(at index: Int32) -> Weapon? { let o = __t.offset(4); return o == 0 ? nil : Weapon.assign(__t.indirect(__t.vector(at: o) + (index * 4)), __t.bb) }
+    
+    func equiped<T: FlatBufferObject>() -> T? {
+        let o = __t.offset(8); return o == 0 ? nil : __t.union(o)
+    }
+    
+    static func getRootAsMonster(bb: ByteBuffer) -> LocalMonster {
+        return LocalMonster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    }
+    
+    @inlinable static func createMonster(builder: inout FlatBufferBuilder,
+                                         offset: Offset<UOffset>,
+                                         equipment: Equipment = .none,
+                                         equippedOffset: UOffset) -> Offset<LocalMonster> {
+        let start = builder.startTable(with: 3)
+        builder.add(element: equippedOffset, def: 0, at: 8)
+        builder.add(offset: offset, at: 4)
+        builder.add(element: equipment.rawValue, def: Equipment.none.rawValue, at: 6)
+        return Offset(offset: builder.endTable(at: start))
+    }
+}
+
+struct Weapon: FlatBufferObject {
+    
+    var __buffer: ByteBuffer! { __t.bb }
+    
+    static let offsets: (name: VOffset, dmg: VOffset) = (4, 6)
+    private var __t: Table
+    
+    init(_ t: Table) { __t = t }
+    init(_ fb: ByteBuffer, o: Int32) { __t = Table(bb: fb, position: o)}
+    
+    var dmg: Int16 { let o = __t.offset(6); return o == 0 ? 0 : __t.readBuffer(of: Int16.self, at: o) }
+    var nameVector: [UInt8]? { return __t.getVector(at: 4) }
+    var name: String? { let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+    
+    static func assign(_ i: Int32, _ bb: ByteBuffer) -> Weapon { return Weapon(Table(bb: bb, position: i)) }
+    
+    @inlinable static func createWeapon(builder: inout FlatBufferBuilder, offset: Offset<String>, dmg: Int16) -> Offset<Weapon> {
+        let _start = builder.startTable(with: 2)
+        Weapon.add(builder: &builder, name: offset)
+        Weapon.add(builder: &builder, dmg: dmg)
+        return Weapon.end(builder: &builder, startOffset: _start)
+    }
+    
+    @inlinable static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Weapon> {
+        return Offset(offset: builder.endTable(at: startOffset))
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+        builder.add(offset: name, at: Weapon.offsets.name)
+    }
+    
+    @inlinable static func add(builder: inout FlatBufferBuilder, dmg: Int16) {
+        builder.add(element: dmg, def: 0, at: Weapon.offsets.dmg)
+    }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift
new file mode 100644
index 0000000..9d63e80
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift
@@ -0,0 +1,116 @@
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersVectors: XCTestCase {
+    
+    func testCreatingTwoCountries() {
+        let norway = "Norway"
+        let denmark = "Denmark"
+        var b = FlatBufferBuilder(initialSize: 20)
+        let noStr = b.create(string: norway)
+        let deStr = b.create(string: denmark)
+        let n = Country.createCountry(builder: &b, offset: noStr, log: 888, lan: 700)
+        let d = Country.createCountry(builder: &b, offset: deStr, log: 200, lan: 100)
+        let vector = [n, d]
+        let vectorOffset = b.createVector(ofOffsets: vector)
+        b.finish(offset: vectorOffset)
+        XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 2, 0, 0, 0, 48, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 18, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 40, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 24, 0, 0, 0, 188, 2, 0, 0, 120, 3, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0])
+    }
+    
+    func testCreateIntArray() {
+        let numbers: [Int32] = [1, 2, 3, 4, 5]
+        var b = FlatBufferBuilder(initialSize: 20)
+        let o = b.createVector(numbers, size: numbers.count)
+        b.finish(offset: o)
+        XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0])
+    }
+    
+    func testCreateEmptyIntArray() {
+        let numbers: [Int32] = []
+        var b = FlatBufferBuilder(initialSize: 20)
+        let o = b.createVector(numbers, size: numbers.count)
+        b.finish(offset: o)
+        XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 0, 0, 0, 0])
+    }
+    
+    func testCreateVectorOfStrings() {
+        let strs = ["Denmark", "Norway"]
+        var b = FlatBufferBuilder(initialSize: 20)
+        let o = b.createVector(ofStrings: strs)
+        b.finish(offset: o)
+        XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 2, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0])
+    }
+    func testCreateSharedStringVector() {
+        let norway = "Norway"
+        let denmark = "Denmark"
+        var b = FlatBufferBuilder(initialSize: 20)
+        let noStr = b.createShared(string: norway)
+        let deStr = b.createShared(string: denmark)
+        let _noStr = b.createShared(string: norway)
+        let _deStr = b.createShared(string: denmark)
+        let v = [noStr, deStr, _noStr, _deStr]
+        let end = b.createVector(ofOffsets: v)
+        b.finish(offset: end)
+        XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 12, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0])
+    }
+    
+    func testReadInt32Array() {
+        let data: [Int32] = [1, 2, 3, 4, 5]
+        var b = FlatBufferBuilder(initialSize: 20)
+        let v = Numbers.createNumbersVector(b: &b, array: data)
+        let end = Numbers.createNumbers(b: &b, o: v)
+        b.finish(offset: end)
+        let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
+        XCTAssertEqual(number.vArrayInt32, [1, 2, 3, 4, 5])
+    }
+    
+    func testReadDoubleArray() {
+        let data: [Double] = [1, 2, 3, 4, 5]
+        var b = FlatBufferBuilder(initialSize: 20)
+        let v = Numbers.createNumbersVector(b: &b, array: data)
+        let end = Numbers.createNumbers(b: &b, o: v)
+        b.finish(offset: end)
+        let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
+        XCTAssertEqual(number.vArrayDouble, [1, 2, 3, 4, 5])
+    }
+}
+
+struct Numbers {
+    
+    private var __t: Table
+    
+    private init(_ t: Table) {
+        __t = t
+    }
+    
+    @inlinable static func getRootAsNumbers(_ bb: ByteBuffer) -> Numbers {
+        return Numbers(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    }
+    
+    var vArrayInt: [Int]? { return __t.getVector(at: 4) }
+    var vArrayInt32: [Int32]? { return __t.getVector(at: 4) }
+    var vArrayDouble: [Double]? { return __t.getVector(at: 4) }
+    var vArrayFloat: [Float32]? { return __t.getVector(at: 4) }
+    
+    static func createNumbersVector(b: inout FlatBufferBuilder, array: [Int]) -> Offset<UOffset> {
+        return b.createVector(array, size: array.count)
+    }
+    
+    static func createNumbersVector(b: inout FlatBufferBuilder, array: [Int32]) -> Offset<UOffset> {
+        return b.createVector(array, size: array.count)
+    }
+    
+    static func createNumbersVector(b: inout FlatBufferBuilder, array: [Double]) -> Offset<UOffset> {
+        return b.createVector(array, size: array.count)
+    }
+    
+    static func createNumbersVector(b: inout FlatBufferBuilder, array: [Float32]) -> Offset<UOffset> {
+        return b.createVector(array, size: array.count)
+    }
+    
+    static func createNumbers(b: inout FlatBufferBuilder, o: Offset<UOffset>) -> Offset<UOffset> {
+        let start = b.startTable(with: 1)
+        b.add(offset: o, at: 4)
+        return Offset(offset: b.endTable(at: start))
+    }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersDoubleTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersDoubleTests.swift
new file mode 100644
index 0000000..6f61ec6
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersDoubleTests.swift
@@ -0,0 +1,69 @@
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersDoubleTests: XCTestCase {
+    
+    let country = "Norway"
+    
+    func testCreateFinish() {
+        var b = FlatBufferBuilder(initialSize: 16)
+        let countryOff = CountryDouble.createCountry(builder: &b, name: country, log: 200, lan: 100)
+        b.finish(offset: countryOff)
+        let v: [UInt8] = [16, 0, 0, 0, 0, 0, 10, 0, 28, 0, 4, 0, 8, 0, 16, 0, 10, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 64, 0, 0, 0, 0, 0, 0, 105, 64, 0, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+        XCTAssertEqual(b.sizedByteArray, v)
+    }
+    
+    func testCreateFinishWithPrefix() {
+        var b = FlatBufferBuilder(initialSize: 16)
+        let countryOff = CountryDouble.createCountry(builder: &b, name: country, log: 200, lan: 100)
+        b.finish(offset: countryOff, addPrefix: true)
+        let v: [UInt8] = [60, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 28, 0, 4, 0, 8, 0, 16, 0, 10, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 64, 0, 0, 0, 0, 0, 0, 105, 64, 0, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+        XCTAssertEqual(b.sizedByteArray, v)
+    }
+}
+
+class CountryDouble {
+    
+    static let offsets: (name: VOffset, lan: VOffset, lng: VOffset) = (4, 6, 8)
+    
+    private var table: Table
+    
+    private init(table t: Table) { table = t }
+    
+    static func getRootAsCountry(_ bb: ByteBuffer) -> CountryDouble {
+        let pos = bb.read(def: Int32.self, position: Int(bb.size))
+        return CountryDouble(table: Table(bb: bb, position: Int32(pos)))
+    }
+    
+    static func createCountry(builder: inout FlatBufferBuilder, name: String, log: Double, lan: Double) -> Offset<Country> {
+        return createCountry(builder: &builder, offset: builder.create(string: name), log: log, lan: lan)
+    }
+    
+    static func createCountry(builder: inout FlatBufferBuilder, offset: Offset<String>, log: Double, lan: Double) -> Offset<Country> {
+        let _start = builder.startTable(with: 3)
+        CountryDouble.add(builder: &builder, lng: log)
+        CountryDouble.add(builder: &builder, lan: lan)
+        CountryDouble.add(builder: &builder, name: offset)
+        return CountryDouble.end(builder: &builder, startOffset: _start)
+    }
+    
+    static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Country> {
+        return Offset(offset: builder.endTable(at: startOffset))
+    }
+    
+    static func add(builder: inout FlatBufferBuilder, name: String) {
+        add(builder: &builder, name: builder.create(string: name))
+    }
+    
+    static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+        builder.add(offset: name, at: Country.offsets.name)
+    }
+    
+    static func add(builder: inout FlatBufferBuilder, lan: Double) {
+        builder.add(element: lan, def: 0, at: Country.offsets.lan)
+    }
+    
+    static func add(builder: inout FlatBufferBuilder, lng: Double) {
+        builder.add(element: lng, def: 0, at: Country.offsets.lng)
+    }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/MutatingBool_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/MutatingBool_generated.swift
new file mode 100644
index 0000000..d51f3d9
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/MutatingBool_generated.swift
@@ -0,0 +1,47 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import FlatBuffers
+
+public struct Property: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 1
+    public static var alignment = 1
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var property: Bool { return _accessor.readBuffer(of: Bool.self, at: 0) }
+    @discardableResult public func mutate(property: Bool) -> Bool { return _accessor.mutate(property, index: 0) }
+}
+
+public func createProperty(builder: inout FlatBufferBuilder, property: Bool = false) -> Offset<UOffset> {
+    builder.createStructOf(size: Property.size, alignment: Property.alignment)
+    builder.reverseAdd(v: property, postion: 0)
+    return builder.endStruct()
+}
+
+public struct TestMutatingBool: FlatBufferObject {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func getRootAsTestMutatingBool(bb: ByteBuffer) -> TestMutatingBool { return TestMutatingBool(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    enum VTOFFSET: VOffset {
+        case b = 4
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var b: Property? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : Property(_accessor.bb, o: o + _accessor.postion) }
+    public static func startTestMutatingBool(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    public static func add(b: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(structOffset: VTOFFSET.b.p) }
+    public static func endTestMutatingBool(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+}
+
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift
new file mode 100644
index 0000000..e1d52cd
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift
@@ -0,0 +1,93 @@
+#if !canImport(ObjectiveC)
+import XCTest
+
+extension FlatBuffersDoubleTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersDoubleTests = [
+        ("testCreateFinish", testCreateFinish),
+        ("testCreateFinishWithPrefix", testCreateFinishWithPrefix),
+    ]
+}
+
+extension FlatBuffersMonsterWriterTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersMonsterWriterTests = [
+        ("testCreateMonster", testCreateMonster),
+        ("testCreateMonsterPrefixed", testCreateMonsterPrefixed),
+        ("testCreateMonsterResizedBuffer", testCreateMonsterResizedBuffer),
+        ("testCreateMonsterUsingCreateMonsterMethodWithNilPos", testCreateMonsterUsingCreateMonsterMethodWithNilPos),
+        ("testCreateMonsterUsingCreateMonsterMethodWithPosX", testCreateMonsterUsingCreateMonsterMethodWithPosX),
+        ("testData", testData),
+        ("testReadFromOtherLanguages", testReadFromOtherLanguages),
+        ("testReadMonsterFromUnsafePointerWithoutCopying", testReadMonsterFromUnsafePointerWithoutCopying),
+    ]
+}
+
+extension FlatBuffersStructsTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersStructsTests = [
+        ("testWritingAndMutatingBools", testWritingAndMutatingBools),
+    ]
+}
+
+extension FlatBuffersTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersTests = [
+        ("testCreateFinish", testCreateFinish),
+        ("testCreateFinishWithPrefix", testCreateFinishWithPrefix),
+        ("testCreateString", testCreateString),
+        ("testEndian", testEndian),
+        ("testOffset", testOffset),
+        ("testReadCountry", testReadCountry),
+        ("testStartTable", testStartTable),
+        ("testWriteNullableStrings", testWriteNullableStrings),
+        ("testWriteOptionalValues", testWriteOptionalValues),
+    ]
+}
+
+extension FlatBuffersUnionTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersUnionTests = [
+        ("testCreateMonstor", testCreateMonstor),
+        ("testEndTableFinish", testEndTableFinish),
+        ("testEnumVector", testEnumVector),
+        ("testUnionVector", testUnionVector),
+    ]
+}
+
+extension FlatBuffersVectors {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FlatBuffersVectors = [
+        ("testCreateEmptyIntArray", testCreateEmptyIntArray),
+        ("testCreateIntArray", testCreateIntArray),
+        ("testCreateSharedStringVector", testCreateSharedStringVector),
+        ("testCreateVectorOfStrings", testCreateVectorOfStrings),
+        ("testCreatingTwoCountries", testCreatingTwoCountries),
+        ("testReadDoubleArray", testReadDoubleArray),
+        ("testReadInt32Array", testReadInt32Array),
+    ]
+}
+
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(FlatBuffersDoubleTests.__allTests__FlatBuffersDoubleTests),
+        testCase(FlatBuffersMonsterWriterTests.__allTests__FlatBuffersMonsterWriterTests),
+        testCase(FlatBuffersStructsTests.__allTests__FlatBuffersStructsTests),
+        testCase(FlatBuffersTests.__allTests__FlatBuffersTests),
+        testCase(FlatBuffersUnionTests.__allTests__FlatBuffersUnionTests),
+        testCase(FlatBuffersVectors.__allTests__FlatBuffersVectors),
+    ]
+}
+#endif
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test.grpc.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test.grpc.swift
new file mode 100644
index 0000000..b2f3ff2
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test.grpc.swift
@@ -0,0 +1,95 @@
+// Generated GRPC code for FlatBuffers swift!
+/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
+/// in case of an issue please open github issue, though it would be maintained
+import Foundation
+import GRPC
+import NIO
+import NIOHTTP1
+import FlatBuffers
+
+public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
+public extension GRPCFlatBufPayload {
+    init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
+        self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
+    }
+    func serialize(into buffer: inout NIO.ByteBuffer) throws {
+        let buf = UnsafeRawBufferPointer(start: self.rawPointer, count: Int(self.size))
+        buffer.writeBytes(buf)
+    }
+}
+extension Message: GRPCFlatBufPayload {}
+
+/// Usage: instantiate MyGame_Example_MonsterStorageServiceClient, then call methods of this protocol to make API calls.
+public protocol MyGame_Example_MonsterStorageService {
+	 func Store(_ request: Message<MyGame_Example_Monster>, callOptions: CallOptions?) -> UnaryCall<Message<MyGame_Example_Monster>,Message<MyGame_Example_Stat>>
+	 func Retrieve(_ request: Message<MyGame_Example_Stat>, callOptions: CallOptions?, handler: @escaping (Message<MyGame_Example_Monster>) -> Void) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>
+	 func GetMaxHitPoint(callOptions: CallOptions?) -> ClientStreamingCall<Message<MyGame_Example_Monster>,Message<MyGame_Example_Stat>>
+	 func GetMinMaxHitPoints(callOptions: CallOptions?, handler: @escaping (Message<MyGame_Example_Stat>) -> Void) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
+}
+
+public final class MyGame_Example_MonsterStorageServiceClient: GRPCClient, MyGame_Example_MonsterStorageService {
+	public let channel: GRPCChannel
+	public var defaultCallOptions: CallOptions
+
+	public init(channel: GRPCChannel, defaultCallOptions: CallOptions = CallOptions()) {
+		self.channel = channel
+		self.defaultCallOptions = defaultCallOptions
+	}
+
+	public func Store(_ request: Message<MyGame_Example_Monster>, callOptions: CallOptions? = nil) -> UnaryCall<Message<MyGame_Example_Monster>,Message<MyGame_Example_Stat>> {
+		return self.makeUnaryCall(path: "/MyGame.Example.MonsterStorage/Store", request: request, callOptions: callOptions ?? self.defaultCallOptions)
+	}
+
+	public func Retrieve(_ request: Message<MyGame_Example_Stat>, callOptions: CallOptions? = nil, handler: @escaping (Message<MyGame_Example_Monster>) -> Void) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>> {
+		return self.makeServerStreamingCall(path: "/MyGame.Example.MonsterStorage/Retrieve", request: request, callOptions: callOptions ?? self.defaultCallOptions, handler: handler)
+	}
+
+	public func GetMaxHitPoint(callOptions: CallOptions? = nil) -> ClientStreamingCall<Message<MyGame_Example_Monster>,Message<MyGame_Example_Stat>> {
+		return self.makeClientStreamingCall(path: "/MyGame.Example.MonsterStorage/GetMaxHitPoint", callOptions: callOptions ?? self.defaultCallOptions)
+	}
+
+	public func GetMinMaxHitPoints(callOptions: CallOptions? = nil, handler: @escaping (Message<MyGame_Example_Stat>) -> Void) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
+		return self.makeBidirectionalStreamingCall(path: "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints", callOptions: callOptions ?? self.defaultCallOptions, handler: handler)
+	}
+}
+
+public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
+	func Store(_ request: Message<MyGame_Example_Monster>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<MyGame_Example_Stat>>
+	func Retrieve(request: Message<MyGame_Example_Stat>, context: StreamingResponseCallContext<Message<MyGame_Example_Monster>>) -> EventLoopFuture<GRPCStatus>
+	func GetMaxHitPoint(context: UnaryResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
+	func GetMinMaxHitPoints(context: StreamingResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
+}
+
+public extension MyGame_Example_MonsterStorageProvider {
+
+	var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
+
+	func handleMethod(_ methodName: Substring, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
+		switch methodName {
+		case "Store":
+		return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { context in
+			return { request in
+				self.Store(request, context: context)
+			}
+		}
+		case "Retrieve":
+		return CallHandlerFactory.makeServerStreaming(callHandlerContext: callHandlerContext) { context in
+			return { request in
+				self.Retrieve(request: request, context: context)
+			}
+		}
+		case "GetMaxHitPoint":
+		return CallHandlerFactory.makeClientStreaming(callHandlerContext: callHandlerContext) { context in
+			self.GetMaxHitPoint(context: context)
+		}
+		case "GetMinMaxHitPoints":
+		return CallHandlerFactory.makeBidirectionalStreaming(callHandlerContext: callHandlerContext) { context in
+			self.GetMinMaxHitPoints(context: context)
+		}
+		default: return nil;
+		}
+	}
+
+}
+
+
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
new file mode 100644
index 0000000..987f078
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
@@ -0,0 +1,1484 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+
+import FlatBuffers
+
+///  Composite components of Monster color.
+public enum MyGame_Example_Color: UInt8, Enum { 
+    public typealias T = UInt8
+    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+    public var value: UInt8 { return self.rawValue }
+    case red = 1
+    ///  \brief color Green
+    ///  Green is bit_flag with value (1u << 1)
+    case green = 2
+    ///  \brief color Blue (1u << 3)
+    case blue = 8
+    
+
+    public static var max: MyGame_Example_Color { return .blue }
+    public static var min: MyGame_Example_Color { return .red }
+}
+
+public enum MyGame_Example_Race: Int8, Enum { 
+    public typealias T = Int8
+    public static var byteSize: Int { return MemoryLayout<Int8>.size }
+    public var value: Int8 { return self.rawValue }
+    case none_ = -1
+    case human = 0
+    case dwarf = 1
+    case elf = 2
+    
+
+    public static var max: MyGame_Example_Race { return .elf }
+    public static var min: MyGame_Example_Race { return .none_ }
+}
+
+public enum MyGame_Example_Any_: UInt8, Enum { 
+    public typealias T = UInt8
+    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+    public var value: UInt8 { return self.rawValue }
+    case none_ = 0
+    case monster = 1
+    case testsimpletablewithenum = 2
+    case mygameExample2Monster = 3
+    
+
+    public static var max: MyGame_Example_Any_ { return .mygameExample2Monster }
+    public static var min: MyGame_Example_Any_ { return .none_ }
+}
+
+public struct MyGame_Example_Any_Union {
+    public var type: MyGame_Example_Any_
+    public var value: NativeTable?
+    public init(_ v: NativeTable?, type: MyGame_Example_Any_) {
+        self.type = type
+        self.value = v
+    }
+    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+        switch type {
+        case .monster:
+            var __obj = value as? MyGame_Example_MonsterT
+            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
+        case .testsimpletablewithenum:
+            var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
+            return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
+        case .mygameExample2Monster:
+            var __obj = value as? MyGame_Example2_MonsterT
+            return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
+        default: return Offset()
+        }
+    }
+}
+public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { 
+    public typealias T = UInt8
+    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+    public var value: UInt8 { return self.rawValue }
+    case none_ = 0
+    case m = 1
+    case ts = 2
+    case m2 = 3
+    
+
+    public static var max: MyGame_Example_AnyUniqueAliases { return .m2 }
+    public static var min: MyGame_Example_AnyUniqueAliases { return .none_ }
+}
+
+public struct MyGame_Example_AnyUniqueAliasesUnion {
+    public var type: MyGame_Example_AnyUniqueAliases
+    public var value: NativeTable?
+    public init(_ v: NativeTable?, type: MyGame_Example_AnyUniqueAliases) {
+        self.type = type
+        self.value = v
+    }
+    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+        switch type {
+        case .m:
+            var __obj = value as? MyGame_Example_MonsterT
+            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
+        case .ts:
+            var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
+            return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
+        case .m2:
+            var __obj = value as? MyGame_Example2_MonsterT
+            return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
+        default: return Offset()
+        }
+    }
+}
+public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { 
+    public typealias T = UInt8
+    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+    public var value: UInt8 { return self.rawValue }
+    case none_ = 0
+    case m1 = 1
+    case m2 = 2
+    case m3 = 3
+    
+
+    public static var max: MyGame_Example_AnyAmbiguousAliases { return .m3 }
+    public static var min: MyGame_Example_AnyAmbiguousAliases { return .none_ }
+}
+
+public struct MyGame_Example_AnyAmbiguousAliasesUnion {
+    public var type: MyGame_Example_AnyAmbiguousAliases
+    public var value: NativeTable?
+    public init(_ v: NativeTable?, type: MyGame_Example_AnyAmbiguousAliases) {
+        self.type = type
+        self.value = v
+    }
+    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+        switch type {
+        case .m1:
+            var __obj = value as? MyGame_Example_MonsterT
+            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
+        case .m2:
+            var __obj = value as? MyGame_Example_MonsterT
+            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
+        case .m3:
+            var __obj = value as? MyGame_Example_MonsterT
+            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
+        default: return Offset()
+        }
+    }
+}
+public struct MyGame_Example_Test: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 4
+    public static var alignment = 2
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var a: Int16 { return _accessor.readBuffer(of: Int16.self, at: 0) }
+    @discardableResult public func mutate(a: Int16) -> Bool { return _accessor.mutate(a, index: 0) }
+    public var b: Int8 { return _accessor.readBuffer(of: Int8.self, at: 2) }
+    @discardableResult public func mutate(b: Int8) -> Bool { return _accessor.mutate(b, index: 2) }
+    
+
+    public mutating func unpack() -> MyGame_Example_TestT {
+        return MyGame_Example_TestT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestT) -> Offset<UOffset> {
+        return createTest(builder: &builder, a: obj.a, b: obj.b)
+    }
+}
+
+public class MyGame_Example_TestT: NativeTable {
+
+    public var a: Int16
+    public var b: Int8
+
+    public init(_ _t: inout MyGame_Example_Test) {
+        a = _t.a
+        b = _t.b
+    }
+
+    public init() {
+        a = 0
+        b = 0
+    }
+
+}
+public struct MyGame_Example_Vec3: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 32
+    public static var alignment = 8
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var x: Float32 { return _accessor.readBuffer(of: Float32.self, at: 0) }
+    @discardableResult public func mutate(x: Float32) -> Bool { return _accessor.mutate(x, index: 0) }
+    public var y: Float32 { return _accessor.readBuffer(of: Float32.self, at: 4) }
+    @discardableResult public func mutate(y: Float32) -> Bool { return _accessor.mutate(y, index: 4) }
+    public var z: Float32 { return _accessor.readBuffer(of: Float32.self, at: 8) }
+    @discardableResult public func mutate(z: Float32) -> Bool { return _accessor.mutate(z, index: 8) }
+    public var test1: Double { return _accessor.readBuffer(of: Double.self, at: 16) }
+    @discardableResult public func mutate(test1: Double) -> Bool { return _accessor.mutate(test1, index: 16) }
+    public var test2: MyGame_Example_Color { return MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: 24)) ?? .red }
+    public var test3: MyGame_Example_Test { return MyGame_Example_Test(_accessor.bb, o: _accessor.postion + 26) }
+    
+
+    public mutating func unpack() -> MyGame_Example_Vec3T {
+        return MyGame_Example_Vec3T(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3T?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3T) -> Offset<UOffset> {
+        return createVec3(builder: &builder, x: obj.x, y: obj.y, z: obj.z, test1: obj.test1, test2: obj.test2, test3a: obj.test3.a, test3b: obj.test3.b)
+    }
+}
+
+public class MyGame_Example_Vec3T: NativeTable {
+
+    public var x: Float32
+    public var y: Float32
+    public var z: Float32
+    public var test1: Double
+    public var test2: MyGame_Example_Color
+    public var test3: MyGame_Example_TestT
+
+    public init(_ _t: inout MyGame_Example_Vec3) {
+        x = _t.x
+        y = _t.y
+        z = _t.z
+        test1 = _t.test1
+        test2 = _t.test2
+        var __test3 = _t.test3
+        test3 = __test3.unpack()
+    }
+
+    public init() {
+        x = 0.0
+        y = 0.0
+        z = 0.0
+        test1 = 0.0
+        test2 = .red
+        test3 = MyGame_Example_TestT()
+    }
+
+}
+public struct MyGame_Example_Ability: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 8
+    public static var alignment = 4
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var id: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 0) }
+    @discardableResult public func mutate(id: UInt32) -> Bool { return _accessor.mutate(id, index: 0) }
+    public var distance: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 4) }
+    @discardableResult public func mutate(distance: UInt32) -> Bool { return _accessor.mutate(distance, index: 4) }
+    
+
+    public mutating func unpack() -> MyGame_Example_AbilityT {
+        return MyGame_Example_AbilityT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_AbilityT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_AbilityT) -> Offset<UOffset> {
+        return createAbility(builder: &builder, id: obj.id, distance: obj.distance)
+    }
+}
+
+public class MyGame_Example_AbilityT: NativeTable {
+
+    public var id: UInt32
+    public var distance: UInt32
+
+    public init(_ _t: inout MyGame_Example_Ability) {
+        id = _t.id
+        distance = _t.distance
+    }
+
+    public init() {
+        id = 0
+        distance = 0
+    }
+
+}
+extension MyGame_Example_Test {
+    @discardableResult
+    public static func createTest(builder: inout FlatBufferBuilder, a: Int16 = 0, b: Int8 = 0) -> Offset<UOffset> {
+        builder.createStructOf(size: MyGame_Example_Test.size, alignment: MyGame_Example_Test.alignment)
+        builder.reverseAdd(v: a, postion: 0)
+        builder.reverseAdd(v: b, postion: 2)
+        return builder.endStruct()
+    }
+
+}
+
+extension MyGame_Example_Vec3 {
+    @discardableResult
+    public static func createVec3(builder: inout FlatBufferBuilder, x: Float32 = 0.0, y: Float32 = 0.0, z: Float32 = 0.0, test1: Double = 0.0, test2: MyGame_Example_Color, test3a: Int16 = 0, test3b: Int8 = 0) -> Offset<UOffset> {
+        builder.createStructOf(size: MyGame_Example_Vec3.size, alignment: MyGame_Example_Vec3.alignment)
+        builder.reverseAdd(v: x, postion: 0)
+        builder.reverseAdd(v: y, postion: 4)
+        builder.reverseAdd(v: z, postion: 8)
+        builder.reverseAdd(v: test1, postion: 16)
+        builder.reverseAdd(v: test2.rawValue, postion: 24)
+        builder.reverseAdd(v: test3a, postion: 26)
+        builder.reverseAdd(v: test3b, postion: 28)
+        return builder.endStruct()
+    }
+
+}
+
+extension MyGame_Example_Ability {
+    @discardableResult
+    public static func createAbility(builder: inout FlatBufferBuilder, id: UInt32 = 0, distance: UInt32 = 0) -> Offset<UOffset> {
+        builder.createStructOf(size: MyGame_Example_Ability.size, alignment: MyGame_Example_Ability.alignment)
+        builder.reverseAdd(v: id, postion: 0)
+        builder.reverseAdd(v: distance, postion: 4)
+        return builder.endStruct()
+    }
+
+}
+
+public struct MyGame_InParentNamespace: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsInParentNamespace(bb: ByteBuffer) -> MyGame_InParentNamespace { return MyGame_InParentNamespace(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public static func startInParentNamespace(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
+    public static func endInParentNamespace(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    
+
+    public mutating func unpack() -> MyGame_InParentNamespaceT {
+        return MyGame_InParentNamespaceT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT) -> Offset<UOffset> {
+        let __root = MyGame_InParentNamespace.startInParentNamespace(&builder)
+        return MyGame_InParentNamespace.endInParentNamespace(&builder, start: __root)
+    }
+}
+
+public class MyGame_InParentNamespaceT: NativeTable {
+
+
+    public init(_ _t: inout MyGame_InParentNamespace) {
+    }
+
+    public init() {
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
+
+}
+public struct MyGame_Example2_Monster: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsMonster(bb: ByteBuffer) -> MyGame_Example2_Monster { return MyGame_Example2_Monster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
+    public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    
+
+    public mutating func unpack() -> MyGame_Example2_MonsterT {
+        return MyGame_Example2_MonsterT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT) -> Offset<UOffset> {
+        let __root = MyGame_Example2_Monster.startMonster(&builder)
+        return MyGame_Example2_Monster.endMonster(&builder, start: __root)
+    }
+}
+
+public class MyGame_Example2_MonsterT: NativeTable {
+
+
+    public init(_ _t: inout MyGame_Example2_Monster) {
+    }
+
+    public init() {
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
+
+}
+internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    internal var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    internal static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    internal static func getRootAsTestSimpleTableWithEnum(bb: ByteBuffer) -> MyGame_Example_TestSimpleTableWithEnum { return MyGame_Example_TestSimpleTableWithEnum(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    internal init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case color = 4
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    internal var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .green : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .green }
+    @discardableResult internal func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
+    internal static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    internal static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
+    internal static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    internal static func createTestSimpleTableWithEnum(
+        _ fbb: inout FlatBufferBuilder,
+        color: MyGame_Example_Color = .green
+    ) -> Offset<UOffset> {
+        let __start = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&fbb)
+        MyGame_Example_TestSimpleTableWithEnum.add(color: color, &fbb)
+        return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&fbb, start: __start)
+    }
+    
+
+    internal mutating func unpack() -> MyGame_Example_TestSimpleTableWithEnumT {
+        return MyGame_Example_TestSimpleTableWithEnumT(&self)
+    }
+    internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset<UOffset> {
+        let __root = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&builder)
+        MyGame_Example_TestSimpleTableWithEnum.add(color: obj.color, &builder)
+        return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&builder, start: __root)
+    }
+}
+
+internal class MyGame_Example_TestSimpleTableWithEnumT: NativeTable {
+
+    internal var color: MyGame_Example_Color
+
+    internal init(_ _t: inout MyGame_Example_TestSimpleTableWithEnum) {
+        color = _t.color
+    }
+
+    internal init() {
+        color = .green
+    }
+
+    internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
+
+}
+public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsStat(bb: ByteBuffer) -> MyGame_Example_Stat { return MyGame_Example_Stat(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case id = 4
+        case val = 6
+        case count = 8
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var id: String? { let o = _accessor.offset(VTOFFSET.id.v); return o == 0 ? nil : _accessor.string(at: o) }
+    public var idSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.id.v) }
+    public var val: Int64 { let o = _accessor.offset(VTOFFSET.val.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    @discardableResult public func mutate(val: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.val.v);  return _accessor.mutate(val, index: o) }
+    public var count: UInt16 { let o = _accessor.offset(VTOFFSET.count.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    @discardableResult public func mutate(count: UInt16) -> Bool {let o = _accessor.offset(VTOFFSET.count.v);  return _accessor.mutate(count, index: o) }
+    public static func startStat(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
+    public static func add(id: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: id, at: VTOFFSET.id.p) }
+    public static func add(val: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: val, def: 0, at: VTOFFSET.val.p) }
+    public static func add(count: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: count, def: 0, at: VTOFFSET.count.p) }
+    public static func endStat(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createStat(
+        _ fbb: inout FlatBufferBuilder,
+        offsetOfId id: Offset<String> = Offset(),
+        val: Int64 = 0,
+        count: UInt16 = 0
+    ) -> Offset<UOffset> {
+        let __start = MyGame_Example_Stat.startStat(&fbb)
+        MyGame_Example_Stat.add(id: id, &fbb)
+        MyGame_Example_Stat.add(val: val, &fbb)
+        MyGame_Example_Stat.add(count: count, &fbb)
+        return MyGame_Example_Stat.endStat(&fbb, start: __start)
+    }
+    
+
+    public mutating func unpack() -> MyGame_Example_StatT {
+        return MyGame_Example_StatT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT) -> Offset<UOffset> {
+        let __id: Offset<String>
+        if let s = obj.id {
+            __id = builder.create(string: s)
+        } else {
+            __id = Offset<String>()
+        }
+
+        let __root = MyGame_Example_Stat.startStat(&builder)
+        MyGame_Example_Stat.add(id: __id, &builder)
+        MyGame_Example_Stat.add(val: obj.val, &builder)
+        MyGame_Example_Stat.add(count: obj.count, &builder)
+        return MyGame_Example_Stat.endStat(&builder, start: __root)
+    }
+}
+
+public class MyGame_Example_StatT: NativeTable {
+
+    public var id: String?
+    public var val: Int64
+    public var count: UInt16
+
+    public init(_ _t: inout MyGame_Example_Stat) {
+        id = _t.id
+        val = _t.val
+        count = _t.count
+    }
+
+    public init() {
+        val = 0
+        count = 0
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
+
+}
+public struct MyGame_Example_Referrable: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsReferrable(bb: ByteBuffer) -> MyGame_Example_Referrable { return MyGame_Example_Referrable(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case id = 4
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var id: UInt64 { let o = _accessor.offset(VTOFFSET.id.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(id: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.id.v);  return _accessor.mutate(id, index: o) }
+    public static func startReferrable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    public static func add(id: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VTOFFSET.id.p) }
+    public static func endReferrable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createReferrable(
+        _ fbb: inout FlatBufferBuilder,
+        id: UInt64 = 0
+    ) -> Offset<UOffset> {
+        let __start = MyGame_Example_Referrable.startReferrable(&fbb)
+        MyGame_Example_Referrable.add(id: id, &fbb)
+        return MyGame_Example_Referrable.endReferrable(&fbb, start: __start)
+    }
+    public static func sortVectorOfReferrable(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
+        var off = offsets
+        off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 4, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 4, fbb: fbb.buffer), fbb: fbb.buffer) < 0 } 
+        return fbb.createVector(ofOffsets: off)
+    }
+    fileprivate static func lookupByKey(vector: Int32, key: UInt64, fbb: ByteBuffer) -> MyGame_Example_Referrable? {
+        var span = fbb.read(def: Int32.self, position: Int(vector - 4))
+        var start: Int32 = 0
+        while span != 0 {
+            var middle = span / 2
+            let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
+            let comp = fbb.read(def: UInt64.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 4, fbb: fbb)))
+            if comp > 0 {
+                span = middle
+            } else if comp < 0 {
+                middle += 1
+                start += middle
+                span -= middle
+            } else {
+                return MyGame_Example_Referrable(fbb, o: tableOffset)
+            }
+        }
+        return nil
+    }
+    
+
+    public mutating func unpack() -> MyGame_Example_ReferrableT {
+        return MyGame_Example_ReferrableT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT) -> Offset<UOffset> {
+        let __root = MyGame_Example_Referrable.startReferrable(&builder)
+        MyGame_Example_Referrable.add(id: obj.id, &builder)
+        return MyGame_Example_Referrable.endReferrable(&builder, start: __root)
+    }
+}
+
+public class MyGame_Example_ReferrableT: NativeTable {
+
+    public var id: UInt64
+
+    public init(_ _t: inout MyGame_Example_Referrable) {
+        id = _t.id
+    }
+
+    public init() {
+        id = 0
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Referrable.self) }
+
+}
+///  an example documentation comment: "monster object"
+public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsMonster(bb: ByteBuffer) -> MyGame_Example_Monster { return MyGame_Example_Monster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case pos = 4
+        case mana = 6
+        case hp = 8
+        case name = 10
+        case inventory = 14
+        case color = 16
+        case testType = 18
+        case test = 20
+        case test4 = 22
+        case testarrayofstring = 24
+        case testarrayoftables = 26
+        case enemy = 28
+        case testnestedflatbuffer = 30
+        case testempty = 32
+        case testbool = 34
+        case testhashs32Fnv1 = 36
+        case testhashu32Fnv1 = 38
+        case testhashs64Fnv1 = 40
+        case testhashu64Fnv1 = 42
+        case testhashs32Fnv1a = 44
+        case testhashu32Fnv1a = 46
+        case testhashs64Fnv1a = 48
+        case testhashu64Fnv1a = 50
+        case testarrayofbools = 52
+        case testf = 54
+        case testf2 = 56
+        case testf3 = 58
+        case testarrayofstring2 = 60
+        case testarrayofsortedstruct = 62
+        case flex = 64
+        case test5 = 66
+        case vectorOfLongs = 68
+        case vectorOfDoubles = 70
+        case parentNamespaceTest = 72
+        case vectorOfReferrables = 74
+        case singleWeakReference = 76
+        case vectorOfWeakReferences = 78
+        case vectorOfStrongReferrables = 80
+        case coOwningReference = 82
+        case vectorOfCoOwningReferences = 84
+        case nonOwningReference = 86
+        case vectorOfNonOwningReferences = 88
+        case anyUniqueType = 90
+        case anyUnique = 92
+        case anyAmbiguousType = 94
+        case anyAmbiguous = 96
+        case vectorOfEnums = 98
+        case signedEnum = 100
+        case testrequirednestedflatbuffer = 102
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var pos: MyGame_Example_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Example_Vec3(_accessor.bb, o: o + _accessor.postion) }
+    public var mana: Int16 { let o = _accessor.offset(VTOFFSET.mana.v); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
+    @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.mana.v);  return _accessor.mutate(mana, index: o) }
+    public var hp: Int16 { let o = _accessor.offset(VTOFFSET.hp.v); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
+    @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.hp.v);  return _accessor.mutate(hp, index: o) }
+    public var name: String! { let o = _accessor.offset(VTOFFSET.name.v); return _accessor.string(at: o) }
+    public var nameSegmentArray: [UInt8]! { return _accessor.getVector(at: VTOFFSET.name.v) }
+    public var inventoryCount: Int32 { let o = _accessor.offset(VTOFFSET.inventory.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func inventory(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.inventory.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var inventory: [UInt8] { return _accessor.getVector(at: VTOFFSET.inventory.v) ?? [] }
+    public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.inventory.v); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
+    public var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .blue : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .blue }
+    @discardableResult public func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
+    public var testType: MyGame_Example_Any_ { let o = _accessor.offset(VTOFFSET.testType.v); return o == 0 ? .none_ : MyGame_Example_Any_(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+    public func test<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.test.v); return o == 0 ? nil : _accessor.union(o) }
+    public var test4Count: Int32 { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func test4(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? nil : MyGame_Example_Test(_accessor.bb, o: _accessor.vector(at: o) + index * 4) }
+    public var testarrayofstringCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofstring.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testarrayofstring(at index: Int32) -> String? { let o = _accessor.offset(VTOFFSET.testarrayofstring.v); return o == 0 ? nil : _accessor.directString(at: _accessor.vector(at: o) + index * 4) }
+    ///  an example documentation comment: this will end up in the generated code
+    ///  multiline too
+    public var testarrayoftablesCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testarrayoftables(at index: Int32) -> MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? nil : MyGame_Example_Monster(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+    public func testarrayoftablesBy(key: String) -> MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? nil : MyGame_Example_Monster.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
+    public var enemy: MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.enemy.v); return o == 0 ? nil : MyGame_Example_Monster(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
+    public var testnestedflatbufferCount: Int32 { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testnestedflatbuffer(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var testnestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testnestedflatbuffer.v) ?? [] }
+    public func mutate(testnestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return _accessor.directMutate(testnestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
+    public var testempty: MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.testempty.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
+    public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    @discardableResult public func mutate(testbool: Byte) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v);  return _accessor.mutate(testbool, index: o) }
+    public var testhashs32Fnv1: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    @discardableResult public func mutate(testhashs32Fnv1: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v);  return _accessor.mutate(testhashs32Fnv1, index: o) }
+    public var testhashu32Fnv1: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    @discardableResult public func mutate(testhashu32Fnv1: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v);  return _accessor.mutate(testhashu32Fnv1, index: o) }
+    public var testhashs64Fnv1: Int64 { let o = _accessor.offset(VTOFFSET.testhashs64Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    @discardableResult public func mutate(testhashs64Fnv1: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs64Fnv1.v);  return _accessor.mutate(testhashs64Fnv1, index: o) }
+    public var testhashu64Fnv1: UInt64 { let o = _accessor.offset(VTOFFSET.testhashu64Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(testhashu64Fnv1: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu64Fnv1.v);  return _accessor.mutate(testhashu64Fnv1, index: o) }
+    public var testhashs32Fnv1a: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    @discardableResult public func mutate(testhashs32Fnv1a: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1a.v);  return _accessor.mutate(testhashs32Fnv1a, index: o) }
+    public var testhashu32Fnv1a: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    @discardableResult public func mutate(testhashu32Fnv1a: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu32Fnv1a.v);  return _accessor.mutate(testhashu32Fnv1a, index: o) }
+    public var testhashs64Fnv1a: Int64 { let o = _accessor.offset(VTOFFSET.testhashs64Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    @discardableResult public func mutate(testhashs64Fnv1a: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs64Fnv1a.v);  return _accessor.mutate(testhashs64Fnv1a, index: o) }
+    public var testhashu64Fnv1a: UInt64 { let o = _accessor.offset(VTOFFSET.testhashu64Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(testhashu64Fnv1a: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu64Fnv1a.v);  return _accessor.mutate(testhashu64Fnv1a, index: o) }
+    public var testarrayofboolsCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testarrayofbools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return o == 0 ? true : 0 != _accessor.directRead(of: Byte.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var testarrayofbools: [Byte] { return _accessor.getVector(at: VTOFFSET.testarrayofbools.v) ?? [] }
+    public func mutate(testarrayofbools: Byte, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return _accessor.directMutate(testarrayofbools, index: _accessor.vector(at: o) + index * 1) }
+    public var testf: Float32 { let o = _accessor.offset(VTOFFSET.testf.v); return o == 0 ? 3.14159 : _accessor.readBuffer(of: Float32.self, at: o) }
+    @discardableResult public func mutate(testf: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf.v);  return _accessor.mutate(testf, index: o) }
+    public var testf2: Float32 { let o = _accessor.offset(VTOFFSET.testf2.v); return o == 0 ? 3.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    @discardableResult public func mutate(testf2: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf2.v);  return _accessor.mutate(testf2, index: o) }
+    public var testf3: Float32 { let o = _accessor.offset(VTOFFSET.testf3.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    @discardableResult public func mutate(testf3: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf3.v);  return _accessor.mutate(testf3, index: o) }
+    public var testarrayofstring2Count: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofstring2.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testarrayofstring2(at index: Int32) -> String? { let o = _accessor.offset(VTOFFSET.testarrayofstring2.v); return o == 0 ? nil : _accessor.directString(at: _accessor.vector(at: o) + index * 4) }
+    public var testarrayofsortedstructCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testarrayofsortedstruct(at index: Int32) -> MyGame_Example_Ability? { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? nil : MyGame_Example_Ability(_accessor.bb, o: _accessor.vector(at: o) + index * 8) }
+    public var flexCount: Int32 { let o = _accessor.offset(VTOFFSET.flex.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func flex(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.flex.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var flex: [UInt8] { return _accessor.getVector(at: VTOFFSET.flex.v) ?? [] }
+    public func mutate(flex: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.flex.v); return _accessor.directMutate(flex, index: _accessor.vector(at: o) + index * 1) }
+    public var test5Count: Int32 { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func test5(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? nil : MyGame_Example_Test(_accessor.bb, o: _accessor.vector(at: o) + index * 4) }
+    public var vectorOfLongsCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfLongs(at index: Int32) -> Int64 { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return o == 0 ? 0 : _accessor.directRead(of: Int64.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfLongs: [Int64] { return _accessor.getVector(at: VTOFFSET.vectorOfLongs.v) ?? [] }
+    public func mutate(vectorOfLongs: Int64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return _accessor.directMutate(vectorOfLongs, index: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfDoublesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfDoubles(at index: Int32) -> Double { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return o == 0 ? 0 : _accessor.directRead(of: Double.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfDoubles: [Double] { return _accessor.getVector(at: VTOFFSET.vectorOfDoubles.v) ?? [] }
+    public func mutate(vectorOfDoubles: Double, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return _accessor.directMutate(vectorOfDoubles, index: _accessor.vector(at: o) + index * 8) }
+    public var parentNamespaceTest: MyGame_InParentNamespace? { let o = _accessor.offset(VTOFFSET.parentNamespaceTest.v); return o == 0 ? nil : MyGame_InParentNamespace(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
+    public var vectorOfReferrablesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfReferrables(at index: Int32) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+    public func vectorOfReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
+    public var singleWeakReference: UInt64 { let o = _accessor.offset(VTOFFSET.singleWeakReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(singleWeakReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.singleWeakReference.v);  return _accessor.mutate(singleWeakReference, index: o) }
+    public var vectorOfWeakReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfWeakReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfWeakReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfWeakReferences.v) ?? [] }
+    public func mutate(vectorOfWeakReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return _accessor.directMutate(vectorOfWeakReferences, index: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfStrongReferrablesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfStrongReferrables(at index: Int32) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+    public func vectorOfStrongReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
+    public var coOwningReference: UInt64 { let o = _accessor.offset(VTOFFSET.coOwningReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(coOwningReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.coOwningReference.v);  return _accessor.mutate(coOwningReference, index: o) }
+    public var vectorOfCoOwningReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfCoOwningReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfCoOwningReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfCoOwningReferences.v) ?? [] }
+    public func mutate(vectorOfCoOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return _accessor.directMutate(vectorOfCoOwningReferences, index: _accessor.vector(at: o) + index * 8) }
+    public var nonOwningReference: UInt64 { let o = _accessor.offset(VTOFFSET.nonOwningReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(nonOwningReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.nonOwningReference.v);  return _accessor.mutate(nonOwningReference, index: o) }
+    public var vectorOfNonOwningReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfNonOwningReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vectorOfNonOwningReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfNonOwningReferences.v) ?? [] }
+    public func mutate(vectorOfNonOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return _accessor.directMutate(vectorOfNonOwningReferences, index: _accessor.vector(at: o) + index * 8) }
+    public var anyUniqueType: MyGame_Example_AnyUniqueAliases { let o = _accessor.offset(VTOFFSET.anyUniqueType.v); return o == 0 ? .none_ : MyGame_Example_AnyUniqueAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+    public func anyUnique<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.anyUnique.v); return o == 0 ? nil : _accessor.union(o) }
+    public var anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases { let o = _accessor.offset(VTOFFSET.anyAmbiguousType.v); return o == 0 ? .none_ : MyGame_Example_AnyAmbiguousAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+    public func anyAmbiguous<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.anyAmbiguous.v); return o == 0 ? nil : _accessor.union(o) }
+    public var vectorOfEnumsCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vectorOfEnums(at index: Int32) -> MyGame_Example_Color? { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? MyGame_Example_Color.red : MyGame_Example_Color(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
+    public var signedEnum: MyGame_Example_Race { let o = _accessor.offset(VTOFFSET.signedEnum.v); return o == 0 ? .none_ : MyGame_Example_Race(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
+    @discardableResult public func mutate(signedEnum: MyGame_Example_Race) -> Bool {let o = _accessor.offset(VTOFFSET.signedEnum.v);  return _accessor.mutate(signedEnum.rawValue, index: o) }
+    public var testrequirednestedflatbufferCount: Int32 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testrequirednestedflatbuffer(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var testrequirednestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testrequirednestedflatbuffer.v) ?? [] }
+    public func mutate(testrequirednestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return _accessor.directMutate(testrequirednestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
+    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 50) }
+    public static func add(pos: Offset<UOffset>?, _ fbb: inout FlatBufferBuilder) { guard pos != nil else { return }; fbb.add(structOffset: VTOFFSET.pos.p) }
+    public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
+    public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
+    public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+    public static func addVectorOf(inventory: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VTOFFSET.inventory.p) }
+    public static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 8, at: VTOFFSET.color.p) }
+    public static func add(testType: MyGame_Example_Any_, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testType.rawValue, def: 0, at: VTOFFSET.testType.p) }
+    public static func add(test: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test, at: VTOFFSET.test.p) }
+    public static func addVectorOf(test4: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test4, at: VTOFFSET.test4.p) }
+    public static func startVectorOfTest4(_ size: Int, in builder: inout FlatBufferBuilder) {
+        builder.startVectorOfStructs(count: size, size: MyGame_Example_Test.size, alignment: MyGame_Example_Test.alignment)
+    }
+    public static func addVectorOf(testarrayofstring: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring, at: VTOFFSET.testarrayofstring.p) }
+    public static func addVectorOf(testarrayoftables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayoftables, at: VTOFFSET.testarrayoftables.p) }
+    public static func add(enemy: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: enemy, at: VTOFFSET.enemy.p) }
+    public static func addVectorOf(testnestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testnestedflatbuffer, at: VTOFFSET.testnestedflatbuffer.p) }
+    public static func add(testempty: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testempty, at: VTOFFSET.testempty.p) }
+    public static func add(testbool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testbool, def: false,
+     at: VTOFFSET.testbool.p) }
+    public static func add(testhashs32Fnv1: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1, def: 0, at: VTOFFSET.testhashs32Fnv1.p) }
+    public static func add(testhashu32Fnv1: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1, def: 0, at: VTOFFSET.testhashu32Fnv1.p) }
+    public static func add(testhashs64Fnv1: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1, def: 0, at: VTOFFSET.testhashs64Fnv1.p) }
+    public static func add(testhashu64Fnv1: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1, def: 0, at: VTOFFSET.testhashu64Fnv1.p) }
+    public static func add(testhashs32Fnv1a: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1a, def: 0, at: VTOFFSET.testhashs32Fnv1a.p) }
+    public static func add(testhashu32Fnv1a: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1a, def: 0, at: VTOFFSET.testhashu32Fnv1a.p) }
+    public static func add(testhashs64Fnv1a: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1a, def: 0, at: VTOFFSET.testhashs64Fnv1a.p) }
+    public static func add(testhashu64Fnv1a: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1a, def: 0, at: VTOFFSET.testhashu64Fnv1a.p) }
+    public static func addVectorOf(testarrayofbools: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofbools, at: VTOFFSET.testarrayofbools.p) }
+    public static func add(testf: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf, def: 3.14159, at: VTOFFSET.testf.p) }
+    public static func add(testf2: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf2, def: 3.0, at: VTOFFSET.testf2.p) }
+    public static func add(testf3: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf3, def: 0.0, at: VTOFFSET.testf3.p) }
+    public static func addVectorOf(testarrayofstring2: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring2, at: VTOFFSET.testarrayofstring2.p) }
+    public static func addVectorOf(testarrayofsortedstruct: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofsortedstruct, at: VTOFFSET.testarrayofsortedstruct.p) }
+    public static func startVectorOfTestarrayofsortedstruct(_ size: Int, in builder: inout FlatBufferBuilder) {
+        builder.startVectorOfStructs(count: size, size: MyGame_Example_Ability.size, alignment: MyGame_Example_Ability.alignment)
+    }
+    public static func addVectorOf(flex: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: flex, at: VTOFFSET.flex.p) }
+    public static func addVectorOf(test5: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test5, at: VTOFFSET.test5.p) }
+    public static func startVectorOfTest5(_ size: Int, in builder: inout FlatBufferBuilder) {
+        builder.startVectorOfStructs(count: size, size: MyGame_Example_Test.size, alignment: MyGame_Example_Test.alignment)
+    }
+    public static func addVectorOf(vectorOfLongs: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfLongs, at: VTOFFSET.vectorOfLongs.p) }
+    public static func addVectorOf(vectorOfDoubles: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfDoubles, at: VTOFFSET.vectorOfDoubles.p) }
+    public static func add(parentNamespaceTest: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: parentNamespaceTest, at: VTOFFSET.parentNamespaceTest.p) }
+    public static func addVectorOf(vectorOfReferrables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfReferrables, at: VTOFFSET.vectorOfReferrables.p) }
+    public static func add(singleWeakReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: singleWeakReference, def: 0, at: VTOFFSET.singleWeakReference.p) }
+    public static func addVectorOf(vectorOfWeakReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfWeakReferences, at: VTOFFSET.vectorOfWeakReferences.p) }
+    public static func addVectorOf(vectorOfStrongReferrables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfStrongReferrables, at: VTOFFSET.vectorOfStrongReferrables.p) }
+    public static func add(coOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: coOwningReference, def: 0, at: VTOFFSET.coOwningReference.p) }
+    public static func addVectorOf(vectorOfCoOwningReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfCoOwningReferences, at: VTOFFSET.vectorOfCoOwningReferences.p) }
+    public static func add(nonOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nonOwningReference, def: 0, at: VTOFFSET.nonOwningReference.p) }
+    public static func addVectorOf(vectorOfNonOwningReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfNonOwningReferences, at: VTOFFSET.vectorOfNonOwningReferences.p) }
+    public static func add(anyUniqueType: MyGame_Example_AnyUniqueAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyUniqueType.rawValue, def: 0, at: VTOFFSET.anyUniqueType.p) }
+    public static func add(anyUnique: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyUnique, at: VTOFFSET.anyUnique.p) }
+    public static func add(anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyAmbiguousType.rawValue, def: 0, at: VTOFFSET.anyAmbiguousType.p) }
+    public static func add(anyAmbiguous: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VTOFFSET.anyAmbiguous.p) }
+    public static func addVectorOf(vectorOfEnums: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VTOFFSET.vectorOfEnums.p) }
+    public static func add(signedEnum: MyGame_Example_Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VTOFFSET.signedEnum.p) }
+    public static func addVectorOf(testrequirednestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VTOFFSET.testrequirednestedflatbuffer.p) }
+    public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
+    public static func sortVectorOfMonster(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
+        var off = offsets
+        off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 10, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 10, fbb: fbb.buffer), fbb: fbb.buffer) < 0 } 
+        return fbb.createVector(ofOffsets: off)
+    }
+    fileprivate static func lookupByKey(vector: Int32, key: String, fbb: ByteBuffer) -> MyGame_Example_Monster? {
+        let key = key.utf8.map { $0 }
+        var span = fbb.read(def: Int32.self, position: Int(vector - 4))
+        var start: Int32 = 0
+        while span != 0 {
+            var middle = span / 2
+            let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
+            let comp = Table.compare(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 10, fbb: fbb), key, fbb: fbb)
+            if comp > 0 {
+                span = middle
+            } else if comp < 0 {
+                middle += 1
+                start += middle
+                span -= middle
+            } else {
+                return MyGame_Example_Monster(fbb, o: tableOffset)
+            }
+        }
+        return nil
+    }
+    
+
+    public mutating func unpack() -> MyGame_Example_MonsterT {
+        return MyGame_Example_MonsterT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT) -> Offset<UOffset> {
+        let __name = builder.create(string: obj.name)
+        let __inventory = builder.createVector(obj.inventory)
+        let __test = obj.test?.pack(builder: &builder) ?? Offset()
+        MyGame_Example_Monster.startVectorOfTest4(obj.test4.count, in: &builder)
+        for i in obj.test4 {
+            guard let _o = i else { continue }
+            MyGame_Example_Test.createTest(builder: &builder, a: _o.a, b: _o.b)
+        }
+        let __test4 = builder.endVectorOfStructs(count: obj.test4.count)
+        let __testarrayofstring = builder.createVector(ofStrings: obj.testarrayofstring.compactMap({ $0 }) )
+        var __testarrayoftables__: [Offset<UOffset>] = []
+        for var i in obj.testarrayoftables {
+            __testarrayoftables__.append(MyGame_Example_Monster.pack(&builder, obj: &i))
+        }
+        let __testarrayoftables = builder.createVector(ofOffsets: __testarrayoftables__)
+        let __enemy = MyGame_Example_Monster.pack(&builder, obj: &obj.enemy)
+        let __testnestedflatbuffer = builder.createVector(obj.testnestedflatbuffer)
+        let __testempty = MyGame_Example_Stat.pack(&builder, obj: &obj.testempty)
+        let __testarrayofbools = builder.createVector(obj.testarrayofbools)
+        let __testarrayofstring2 = builder.createVector(ofStrings: obj.testarrayofstring2.compactMap({ $0 }) )
+        MyGame_Example_Monster.startVectorOfTestarrayofsortedstruct(obj.testarrayofsortedstruct.count, in: &builder)
+        for i in obj.testarrayofsortedstruct {
+            guard let _o = i else { continue }
+            MyGame_Example_Ability.createAbility(builder: &builder, id: _o.id, distance: _o.distance)
+        }
+        let __testarrayofsortedstruct = builder.endVectorOfStructs(count: obj.testarrayofsortedstruct.count)
+        let __flex = builder.createVector(obj.flex)
+        MyGame_Example_Monster.startVectorOfTest5(obj.test5.count, in: &builder)
+        for i in obj.test5 {
+            guard let _o = i else { continue }
+            MyGame_Example_Test.createTest(builder: &builder, a: _o.a, b: _o.b)
+        }
+        let __test5 = builder.endVectorOfStructs(count: obj.test5.count)
+        let __vectorOfLongs = builder.createVector(obj.vectorOfLongs)
+        let __vectorOfDoubles = builder.createVector(obj.vectorOfDoubles)
+        let __parentNamespaceTest = MyGame_InParentNamespace.pack(&builder, obj: &obj.parentNamespaceTest)
+        var __vectorOfReferrables__: [Offset<UOffset>] = []
+        for var i in obj.vectorOfReferrables {
+            __vectorOfReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
+        }
+        let __vectorOfReferrables = builder.createVector(ofOffsets: __vectorOfReferrables__)
+        let __vectorOfWeakReferences = builder.createVector(obj.vectorOfWeakReferences)
+        var __vectorOfStrongReferrables__: [Offset<UOffset>] = []
+        for var i in obj.vectorOfStrongReferrables {
+            __vectorOfStrongReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
+        }
+        let __vectorOfStrongReferrables = builder.createVector(ofOffsets: __vectorOfStrongReferrables__)
+        let __vectorOfCoOwningReferences = builder.createVector(obj.vectorOfCoOwningReferences)
+        let __vectorOfNonOwningReferences = builder.createVector(obj.vectorOfNonOwningReferences)
+        let __anyUnique = obj.anyUnique?.pack(builder: &builder) ?? Offset()
+        let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
+        let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
+        let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
+        let __root = MyGame_Example_Monster.startMonster(&builder)
+        MyGame_Example_Monster.add(pos: obj.pos.map { MyGame_Example_Vec3.createVec3(builder: &builder, x: $0.x, y: $0.y, z: $0.z, test1: $0.test1, test2: $0.test2, test3a: $0.test3.a, test3b: $0.test3.b) }, &builder)
+        MyGame_Example_Monster.add(mana: obj.mana, &builder)
+        MyGame_Example_Monster.add(hp: obj.hp, &builder)
+        MyGame_Example_Monster.add(name: __name, &builder)
+        MyGame_Example_Monster.addVectorOf(inventory: __inventory, &builder)
+        MyGame_Example_Monster.add(color: obj.color, &builder)
+        if let o = obj.test?.type {
+          MyGame_Example_Monster.add(testType: o, &builder)
+          MyGame_Example_Monster.add(test: __test, &builder)
+        }
+
+        MyGame_Example_Monster.addVectorOf(test4: __test4, &builder)
+        MyGame_Example_Monster.addVectorOf(testarrayofstring: __testarrayofstring, &builder)
+        MyGame_Example_Monster.addVectorOf(testarrayoftables: __testarrayoftables, &builder)
+        MyGame_Example_Monster.add(enemy: __enemy, &builder)
+        MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: __testnestedflatbuffer, &builder)
+        MyGame_Example_Monster.add(testempty: __testempty, &builder)
+        MyGame_Example_Monster.add(testbool: obj.testbool, &builder)
+        MyGame_Example_Monster.add(testhashs32Fnv1: obj.testhashs32Fnv1, &builder)
+        MyGame_Example_Monster.add(testhashu32Fnv1: obj.testhashu32Fnv1, &builder)
+        MyGame_Example_Monster.add(testhashs64Fnv1: obj.testhashs64Fnv1, &builder)
+        MyGame_Example_Monster.add(testhashu64Fnv1: obj.testhashu64Fnv1, &builder)
+        MyGame_Example_Monster.add(testhashs32Fnv1a: obj.testhashs32Fnv1a, &builder)
+        MyGame_Example_Monster.add(testhashu32Fnv1a: obj.testhashu32Fnv1a, &builder)
+        MyGame_Example_Monster.add(testhashs64Fnv1a: obj.testhashs64Fnv1a, &builder)
+        MyGame_Example_Monster.add(testhashu64Fnv1a: obj.testhashu64Fnv1a, &builder)
+        MyGame_Example_Monster.addVectorOf(testarrayofbools: __testarrayofbools, &builder)
+        MyGame_Example_Monster.add(testf: obj.testf, &builder)
+        MyGame_Example_Monster.add(testf2: obj.testf2, &builder)
+        MyGame_Example_Monster.add(testf3: obj.testf3, &builder)
+        MyGame_Example_Monster.addVectorOf(testarrayofstring2: __testarrayofstring2, &builder)
+        MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: __testarrayofsortedstruct, &builder)
+        MyGame_Example_Monster.addVectorOf(flex: __flex, &builder)
+        MyGame_Example_Monster.addVectorOf(test5: __test5, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfLongs: __vectorOfLongs, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfDoubles: __vectorOfDoubles, &builder)
+        MyGame_Example_Monster.add(parentNamespaceTest: __parentNamespaceTest, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfReferrables: __vectorOfReferrables, &builder)
+        MyGame_Example_Monster.add(singleWeakReference: obj.singleWeakReference, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: __vectorOfWeakReferences, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: __vectorOfStrongReferrables, &builder)
+        MyGame_Example_Monster.add(coOwningReference: obj.coOwningReference, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: __vectorOfCoOwningReferences, &builder)
+        MyGame_Example_Monster.add(nonOwningReference: obj.nonOwningReference, &builder)
+        MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: __vectorOfNonOwningReferences, &builder)
+        if let o = obj.anyUnique?.type {
+          MyGame_Example_Monster.add(anyUniqueType: o, &builder)
+          MyGame_Example_Monster.add(anyUnique: __anyUnique, &builder)
+        }
+
+        if let o = obj.anyAmbiguous?.type {
+          MyGame_Example_Monster.add(anyAmbiguousType: o, &builder)
+          MyGame_Example_Monster.add(anyAmbiguous: __anyAmbiguous, &builder)
+        }
+
+        MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
+        MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
+        MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
+        return MyGame_Example_Monster.endMonster(&builder, start: __root)
+    }
+}
+
+public class MyGame_Example_MonsterT: NativeTable {
+
+    public var pos: MyGame_Example_Vec3T?
+    public var mana: Int16
+    public var hp: Int16
+    public var name: String
+    public var inventory: [UInt8]
+    public var color: MyGame_Example_Color
+    public var test: MyGame_Example_Any_Union?
+    public var test4: [MyGame_Example_TestT?]
+    public var testarrayofstring: [String?]
+    public var testarrayoftables: [MyGame_Example_MonsterT?]
+    public var enemy: MyGame_Example_MonsterT?
+    public var testnestedflatbuffer: [UInt8]
+    public var testempty: MyGame_Example_StatT?
+    public var testbool: Bool
+    public var testhashs32Fnv1: Int32
+    public var testhashu32Fnv1: UInt32
+    public var testhashs64Fnv1: Int64
+    public var testhashu64Fnv1: UInt64
+    public var testhashs32Fnv1a: Int32
+    public var testhashu32Fnv1a: UInt32
+    public var testhashs64Fnv1a: Int64
+    public var testhashu64Fnv1a: UInt64
+    public var testarrayofbools: [Bool]
+    public var testf: Float32
+    public var testf2: Float32
+    public var testf3: Float32
+    public var testarrayofstring2: [String?]
+    public var testarrayofsortedstruct: [MyGame_Example_AbilityT?]
+    public var flex: [UInt8]
+    public var test5: [MyGame_Example_TestT?]
+    public var vectorOfLongs: [Int64]
+    public var vectorOfDoubles: [Double]
+    public var parentNamespaceTest: MyGame_InParentNamespaceT?
+    public var vectorOfReferrables: [MyGame_Example_ReferrableT?]
+    public var singleWeakReference: UInt64
+    public var vectorOfWeakReferences: [UInt64]
+    public var vectorOfStrongReferrables: [MyGame_Example_ReferrableT?]
+    public var coOwningReference: UInt64
+    public var vectorOfCoOwningReferences: [UInt64]
+    public var nonOwningReference: UInt64
+    public var vectorOfNonOwningReferences: [UInt64]
+    public var anyUnique: MyGame_Example_AnyUniqueAliasesUnion?
+    public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
+    public var vectorOfEnums: [MyGame_Example_Color]
+    public var signedEnum: MyGame_Example_Race
+    public var testrequirednestedflatbuffer: [UInt8]
+
+    public init(_ _t: inout MyGame_Example_Monster) {
+        var __pos = _t.pos
+        pos = __pos?.unpack()
+        mana = _t.mana
+        hp = _t.hp
+        name = _t.name
+        inventory = []
+        for index in 0..<_t.inventoryCount {
+            inventory.append(_t.inventory(at: index))
+        }
+        color = _t.color
+        switch _t.testType {
+        case .monster:
+            var _v = _t.test(type: MyGame_Example_Monster.self)
+            test = MyGame_Example_Any_Union(_v?.unpack(), type: .monster)
+        case .testsimpletablewithenum:
+            var _v = _t.test(type: MyGame_Example_TestSimpleTableWithEnum.self)
+            test = MyGame_Example_Any_Union(_v?.unpack(), type: .testsimpletablewithenum)
+        case .mygameExample2Monster:
+            var _v = _t.test(type: MyGame_Example2_Monster.self)
+            test = MyGame_Example_Any_Union(_v?.unpack(), type: .mygameExample2Monster)
+        default: break
+        }
+        test4 = []
+        for index in 0..<_t.test4Count {
+            var __v_ = _t.test4(at: index)
+            test4.append(__v_?.unpack())
+        }
+        testarrayofstring = []
+        for index in 0..<_t.testarrayofstringCount {
+            testarrayofstring.append(_t.testarrayofstring(at: index))
+        }
+        testarrayoftables = []
+        for index in 0..<_t.testarrayoftablesCount {
+            var __v_ = _t.testarrayoftables(at: index)
+            testarrayoftables.append(__v_?.unpack())
+        }
+        var __enemy = _t.enemy
+        enemy = __enemy?.unpack()
+        testnestedflatbuffer = []
+        for index in 0..<_t.testnestedflatbufferCount {
+            testnestedflatbuffer.append(_t.testnestedflatbuffer(at: index))
+        }
+        var __testempty = _t.testempty
+        testempty = __testempty?.unpack()
+        testbool = _t.testbool
+        testhashs32Fnv1 = _t.testhashs32Fnv1
+        testhashu32Fnv1 = _t.testhashu32Fnv1
+        testhashs64Fnv1 = _t.testhashs64Fnv1
+        testhashu64Fnv1 = _t.testhashu64Fnv1
+        testhashs32Fnv1a = _t.testhashs32Fnv1a
+        testhashu32Fnv1a = _t.testhashu32Fnv1a
+        testhashs64Fnv1a = _t.testhashs64Fnv1a
+        testhashu64Fnv1a = _t.testhashu64Fnv1a
+        testarrayofbools = []
+        for index in 0..<_t.testarrayofboolsCount {
+            testarrayofbools.append(_t.testarrayofbools(at: index))
+        }
+        testf = _t.testf
+        testf2 = _t.testf2
+        testf3 = _t.testf3
+        testarrayofstring2 = []
+        for index in 0..<_t.testarrayofstring2Count {
+            testarrayofstring2.append(_t.testarrayofstring2(at: index))
+        }
+        testarrayofsortedstruct = []
+        for index in 0..<_t.testarrayofsortedstructCount {
+            var __v_ = _t.testarrayofsortedstruct(at: index)
+            testarrayofsortedstruct.append(__v_?.unpack())
+        }
+        flex = []
+        for index in 0..<_t.flexCount {
+            flex.append(_t.flex(at: index))
+        }
+        test5 = []
+        for index in 0..<_t.test5Count {
+            var __v_ = _t.test5(at: index)
+            test5.append(__v_?.unpack())
+        }
+        vectorOfLongs = []
+        for index in 0..<_t.vectorOfLongsCount {
+            vectorOfLongs.append(_t.vectorOfLongs(at: index))
+        }
+        vectorOfDoubles = []
+        for index in 0..<_t.vectorOfDoublesCount {
+            vectorOfDoubles.append(_t.vectorOfDoubles(at: index))
+        }
+        var __parentNamespaceTest = _t.parentNamespaceTest
+        parentNamespaceTest = __parentNamespaceTest?.unpack()
+        vectorOfReferrables = []
+        for index in 0..<_t.vectorOfReferrablesCount {
+            var __v_ = _t.vectorOfReferrables(at: index)
+            vectorOfReferrables.append(__v_?.unpack())
+        }
+        singleWeakReference = _t.singleWeakReference
+        vectorOfWeakReferences = []
+        for index in 0..<_t.vectorOfWeakReferencesCount {
+            vectorOfWeakReferences.append(_t.vectorOfWeakReferences(at: index))
+        }
+        vectorOfStrongReferrables = []
+        for index in 0..<_t.vectorOfStrongReferrablesCount {
+            var __v_ = _t.vectorOfStrongReferrables(at: index)
+            vectorOfStrongReferrables.append(__v_?.unpack())
+        }
+        coOwningReference = _t.coOwningReference
+        vectorOfCoOwningReferences = []
+        for index in 0..<_t.vectorOfCoOwningReferencesCount {
+            vectorOfCoOwningReferences.append(_t.vectorOfCoOwningReferences(at: index))
+        }
+        nonOwningReference = _t.nonOwningReference
+        vectorOfNonOwningReferences = []
+        for index in 0..<_t.vectorOfNonOwningReferencesCount {
+            vectorOfNonOwningReferences.append(_t.vectorOfNonOwningReferences(at: index))
+        }
+        switch _t.anyUniqueType {
+        case .m:
+            var _v = _t.anyUnique(type: MyGame_Example_Monster.self)
+            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m)
+        case .ts:
+            var _v = _t.anyUnique(type: MyGame_Example_TestSimpleTableWithEnum.self)
+            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .ts)
+        case .m2:
+            var _v = _t.anyUnique(type: MyGame_Example2_Monster.self)
+            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m2)
+        default: break
+        }
+        switch _t.anyAmbiguousType {
+        case .m1:
+            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
+            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m1)
+        case .m2:
+            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
+            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m2)
+        case .m3:
+            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
+            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m3)
+        default: break
+        }
+        vectorOfEnums = []
+        for index in 0..<_t.vectorOfEnumsCount {
+            vectorOfEnums.append(_t.vectorOfEnums(at: index)!)
+        }
+        signedEnum = _t.signedEnum
+        testrequirednestedflatbuffer = []
+        for index in 0..<_t.testrequirednestedflatbufferCount {
+            testrequirednestedflatbuffer.append(_t.testrequirednestedflatbuffer(at: index))
+        }
+    }
+
+    public init() {
+        pos = MyGame_Example_Vec3T()
+        mana = 150
+        hp = 100
+        name = ""
+        inventory = []
+        color = .blue
+        test4 = []
+        testarrayofstring = []
+        testarrayoftables = []
+        enemy = MyGame_Example_MonsterT()
+        testnestedflatbuffer = []
+        testempty = MyGame_Example_StatT()
+        testbool = false
+        testhashs32Fnv1 = 0
+        testhashu32Fnv1 = 0
+        testhashs64Fnv1 = 0
+        testhashu64Fnv1 = 0
+        testhashs32Fnv1a = 0
+        testhashu32Fnv1a = 0
+        testhashs64Fnv1a = 0
+        testhashu64Fnv1a = 0
+        testarrayofbools = []
+        testf = 3.14159
+        testf2 = 3.0
+        testf3 = 0.0
+        testarrayofstring2 = []
+        testarrayofsortedstruct = []
+        flex = []
+        test5 = []
+        vectorOfLongs = []
+        vectorOfDoubles = []
+        parentNamespaceTest = MyGame_InParentNamespaceT()
+        vectorOfReferrables = []
+        singleWeakReference = 0
+        vectorOfWeakReferences = []
+        vectorOfStrongReferrables = []
+        coOwningReference = 0
+        vectorOfCoOwningReferences = []
+        nonOwningReference = 0
+        vectorOfNonOwningReferences = []
+        vectorOfEnums = []
+        signedEnum = .none_
+        testrequirednestedflatbuffer = []
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
+
+}
+public struct MyGame_Example_TypeAliases: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+    public static func getRootAsTypeAliases(bb: ByteBuffer) -> MyGame_Example_TypeAliases { return MyGame_Example_TypeAliases(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case i8 = 4
+        case u8 = 6
+        case i16 = 8
+        case u16 = 10
+        case i32 = 12
+        case u32 = 14
+        case i64 = 16
+        case u64 = 18
+        case f32 = 20
+        case f64 = 22
+        case v8 = 24
+        case vf64 = 26
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var i8: Int8 { let o = _accessor.offset(VTOFFSET.i8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
+    @discardableResult public func mutate(i8: Int8) -> Bool {let o = _accessor.offset(VTOFFSET.i8.v);  return _accessor.mutate(i8, index: o) }
+    public var u8: UInt8 { let o = _accessor.offset(VTOFFSET.u8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
+    @discardableResult public func mutate(u8: UInt8) -> Bool {let o = _accessor.offset(VTOFFSET.u8.v);  return _accessor.mutate(u8, index: o) }
+    public var i16: Int16 { let o = _accessor.offset(VTOFFSET.i16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+    @discardableResult public func mutate(i16: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.i16.v);  return _accessor.mutate(i16, index: o) }
+    public var u16: UInt16 { let o = _accessor.offset(VTOFFSET.u16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    @discardableResult public func mutate(u16: UInt16) -> Bool {let o = _accessor.offset(VTOFFSET.u16.v);  return _accessor.mutate(u16, index: o) }
+    public var i32: Int32 { let o = _accessor.offset(VTOFFSET.i32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    @discardableResult public func mutate(i32: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.i32.v);  return _accessor.mutate(i32, index: o) }
+    public var u32: UInt32 { let o = _accessor.offset(VTOFFSET.u32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    @discardableResult public func mutate(u32: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.u32.v);  return _accessor.mutate(u32, index: o) }
+    public var i64: Int64 { let o = _accessor.offset(VTOFFSET.i64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    @discardableResult public func mutate(i64: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.i64.v);  return _accessor.mutate(i64, index: o) }
+    public var u64: UInt64 { let o = _accessor.offset(VTOFFSET.u64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    @discardableResult public func mutate(u64: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.u64.v);  return _accessor.mutate(u64, index: o) }
+    public var f32: Float32 { let o = _accessor.offset(VTOFFSET.f32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    @discardableResult public func mutate(f32: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.f32.v);  return _accessor.mutate(f32, index: o) }
+    public var f64: Double { let o = _accessor.offset(VTOFFSET.f64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+    @discardableResult public func mutate(f64: Double) -> Bool {let o = _accessor.offset(VTOFFSET.f64.v);  return _accessor.mutate(f64, index: o) }
+    public var v8Count: Int32 { let o = _accessor.offset(VTOFFSET.v8.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func v8(at index: Int32) -> Int8 { let o = _accessor.offset(VTOFFSET.v8.v); return o == 0 ? 0 : _accessor.directRead(of: Int8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var v8: [Int8] { return _accessor.getVector(at: VTOFFSET.v8.v) ?? [] }
+    public func mutate(v8: Int8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.v8.v); return _accessor.directMutate(v8, index: _accessor.vector(at: o) + index * 1) }
+    public var vf64Count: Int32 { let o = _accessor.offset(VTOFFSET.vf64.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func vf64(at index: Int32) -> Double { let o = _accessor.offset(VTOFFSET.vf64.v); return o == 0 ? 0 : _accessor.directRead(of: Double.self, offset: _accessor.vector(at: o) + index * 8) }
+    public var vf64: [Double] { return _accessor.getVector(at: VTOFFSET.vf64.v) ?? [] }
+    public func mutate(vf64: Double, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vf64.v); return _accessor.directMutate(vf64, index: _accessor.vector(at: o) + index * 8) }
+    public static func startTypeAliases(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 12) }
+    public static func add(i8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i8, def: 0, at: VTOFFSET.i8.p) }
+    public static func add(u8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u8, def: 0, at: VTOFFSET.u8.p) }
+    public static func add(i16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i16, def: 0, at: VTOFFSET.i16.p) }
+    public static func add(u16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u16, def: 0, at: VTOFFSET.u16.p) }
+    public static func add(i32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i32, def: 0, at: VTOFFSET.i32.p) }
+    public static func add(u32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u32, def: 0, at: VTOFFSET.u32.p) }
+    public static func add(i64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i64, def: 0, at: VTOFFSET.i64.p) }
+    public static func add(u64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u64, def: 0, at: VTOFFSET.u64.p) }
+    public static func add(f32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f32, def: 0.0, at: VTOFFSET.f32.p) }
+    public static func add(f64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f64, def: 0.0, at: VTOFFSET.f64.p) }
+    public static func addVectorOf(v8: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: v8, at: VTOFFSET.v8.p) }
+    public static func addVectorOf(vf64: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vf64, at: VTOFFSET.vf64.p) }
+    public static func endTypeAliases(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createTypeAliases(
+        _ fbb: inout FlatBufferBuilder,
+        i8: Int8 = 0,
+        u8: UInt8 = 0,
+        i16: Int16 = 0,
+        u16: UInt16 = 0,
+        i32: Int32 = 0,
+        u32: UInt32 = 0,
+        i64: Int64 = 0,
+        u64: UInt64 = 0,
+        f32: Float32 = 0.0,
+        f64: Double = 0.0,
+        vectorOfV8 v8: Offset<UOffset> = Offset(),
+        vectorOfVf64 vf64: Offset<UOffset> = Offset()
+    ) -> Offset<UOffset> {
+        let __start = MyGame_Example_TypeAliases.startTypeAliases(&fbb)
+        MyGame_Example_TypeAliases.add(i8: i8, &fbb)
+        MyGame_Example_TypeAliases.add(u8: u8, &fbb)
+        MyGame_Example_TypeAliases.add(i16: i16, &fbb)
+        MyGame_Example_TypeAliases.add(u16: u16, &fbb)
+        MyGame_Example_TypeAliases.add(i32: i32, &fbb)
+        MyGame_Example_TypeAliases.add(u32: u32, &fbb)
+        MyGame_Example_TypeAliases.add(i64: i64, &fbb)
+        MyGame_Example_TypeAliases.add(u64: u64, &fbb)
+        MyGame_Example_TypeAliases.add(f32: f32, &fbb)
+        MyGame_Example_TypeAliases.add(f64: f64, &fbb)
+        MyGame_Example_TypeAliases.addVectorOf(v8: v8, &fbb)
+        MyGame_Example_TypeAliases.addVectorOf(vf64: vf64, &fbb)
+        return MyGame_Example_TypeAliases.endTypeAliases(&fbb, start: __start)
+    }
+    
+
+    public mutating func unpack() -> MyGame_Example_TypeAliasesT {
+        return MyGame_Example_TypeAliasesT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT) -> Offset<UOffset> {
+        let __v8 = builder.createVector(obj.v8)
+        let __vf64 = builder.createVector(obj.vf64)
+        let __root = MyGame_Example_TypeAliases.startTypeAliases(&builder)
+        MyGame_Example_TypeAliases.add(i8: obj.i8, &builder)
+        MyGame_Example_TypeAliases.add(u8: obj.u8, &builder)
+        MyGame_Example_TypeAliases.add(i16: obj.i16, &builder)
+        MyGame_Example_TypeAliases.add(u16: obj.u16, &builder)
+        MyGame_Example_TypeAliases.add(i32: obj.i32, &builder)
+        MyGame_Example_TypeAliases.add(u32: obj.u32, &builder)
+        MyGame_Example_TypeAliases.add(i64: obj.i64, &builder)
+        MyGame_Example_TypeAliases.add(u64: obj.u64, &builder)
+        MyGame_Example_TypeAliases.add(f32: obj.f32, &builder)
+        MyGame_Example_TypeAliases.add(f64: obj.f64, &builder)
+        MyGame_Example_TypeAliases.addVectorOf(v8: __v8, &builder)
+        MyGame_Example_TypeAliases.addVectorOf(vf64: __vf64, &builder)
+        return MyGame_Example_TypeAliases.endTypeAliases(&builder, start: __root)
+    }
+}
+
+public class MyGame_Example_TypeAliasesT: NativeTable {
+
+    public var i8: Int8
+    public var u8: UInt8
+    public var i16: Int16
+    public var u16: UInt16
+    public var i32: Int32
+    public var u32: UInt32
+    public var i64: Int64
+    public var u64: UInt64
+    public var f32: Float32
+    public var f64: Double
+    public var v8: [Int8]
+    public var vf64: [Double]
+
+    public init(_ _t: inout MyGame_Example_TypeAliases) {
+        i8 = _t.i8
+        u8 = _t.u8
+        i16 = _t.i16
+        u16 = _t.u16
+        i32 = _t.i32
+        u32 = _t.u32
+        i64 = _t.i64
+        u64 = _t.u64
+        f32 = _t.f32
+        f64 = _t.f64
+        v8 = []
+        for index in 0..<_t.v8Count {
+            v8.append(_t.v8(at: index))
+        }
+        vf64 = []
+        for index in 0..<_t.vf64Count {
+            vf64.append(_t.vf64(at: index))
+        }
+    }
+
+    public init() {
+        i8 = 0
+        u8 = 0
+        i16 = 0
+        u16 = 0
+        i32 = 0
+        u32 = 0
+        i64 = 0
+        u64 = 0
+        f32 = 0.0
+        f64 = 0.0
+        v8 = []
+        vf64 = []
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TypeAliases.self) }
+
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift
new file mode 100644
index 0000000..6098397
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift
@@ -0,0 +1,227 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+
+import FlatBuffers
+
+public enum optional_scalars_OptionalByte: Int8, Enum { 
+    public typealias T = Int8
+    public static var byteSize: Int { return MemoryLayout<Int8>.size }
+    public var value: Int8 { return self.rawValue }
+    case none_ = 0
+    case one = 1
+    case two = 2
+    
+
+    public static var max: optional_scalars_OptionalByte { return .two }
+    public static var min: optional_scalars_OptionalByte { return .none_ }
+}
+
+public struct optional_scalars_ScalarStuff: FlatBufferObject {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "NULL", addPrefix: prefix) }
+    public static func getRootAsScalarStuff(bb: ByteBuffer) -> optional_scalars_ScalarStuff { return optional_scalars_ScalarStuff(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case justI8 = 4
+        case maybeI8 = 6
+        case defaultI8 = 8
+        case justU8 = 10
+        case maybeU8 = 12
+        case defaultU8 = 14
+        case justI16 = 16
+        case maybeI16 = 18
+        case defaultI16 = 20
+        case justU16 = 22
+        case maybeU16 = 24
+        case defaultU16 = 26
+        case justI32 = 28
+        case maybeI32 = 30
+        case defaultI32 = 32
+        case justU32 = 34
+        case maybeU32 = 36
+        case defaultU32 = 38
+        case justI64 = 40
+        case maybeI64 = 42
+        case defaultI64 = 44
+        case justU64 = 46
+        case maybeU64 = 48
+        case defaultU64 = 50
+        case justF32 = 52
+        case maybeF32 = 54
+        case defaultF32 = 56
+        case justF64 = 58
+        case maybeF64 = 60
+        case defaultF64 = 62
+        case justBool = 64
+        case maybeBool = 66
+        case defaultBool = 68
+        case justEnum = 70
+        case maybeEnum = 72
+        case defaultEnum = 74
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var justI8: Int8 { let o = _accessor.offset(VTOFFSET.justI8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var maybeI8: Int8? { let o = _accessor.offset(VTOFFSET.maybeI8.v); return o == 0 ? nil : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var defaultI8: Int8 { let o = _accessor.offset(VTOFFSET.defaultI8.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var justU8: UInt8 { let o = _accessor.offset(VTOFFSET.justU8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var maybeU8: UInt8? { let o = _accessor.offset(VTOFFSET.maybeU8.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var defaultU8: UInt8 { let o = _accessor.offset(VTOFFSET.defaultU8.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var justI16: Int16 { let o = _accessor.offset(VTOFFSET.justI16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var maybeI16: Int16? { let o = _accessor.offset(VTOFFSET.maybeI16.v); return o == 0 ? nil : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var defaultI16: Int16 { let o = _accessor.offset(VTOFFSET.defaultI16.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var justU16: UInt16 { let o = _accessor.offset(VTOFFSET.justU16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var maybeU16: UInt16? { let o = _accessor.offset(VTOFFSET.maybeU16.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var defaultU16: UInt16 { let o = _accessor.offset(VTOFFSET.defaultU16.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var justI32: Int32 { let o = _accessor.offset(VTOFFSET.justI32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var maybeI32: Int32? { let o = _accessor.offset(VTOFFSET.maybeI32.v); return o == 0 ? nil : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var defaultI32: Int32 { let o = _accessor.offset(VTOFFSET.defaultI32.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var justU32: UInt32 { let o = _accessor.offset(VTOFFSET.justU32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var maybeU32: UInt32? { let o = _accessor.offset(VTOFFSET.maybeU32.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var defaultU32: UInt32 { let o = _accessor.offset(VTOFFSET.defaultU32.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var justI64: Int64 { let o = _accessor.offset(VTOFFSET.justI64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var maybeI64: Int64? { let o = _accessor.offset(VTOFFSET.maybeI64.v); return o == 0 ? nil : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var defaultI64: Int64 { let o = _accessor.offset(VTOFFSET.defaultI64.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var justU64: UInt64 { let o = _accessor.offset(VTOFFSET.justU64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var maybeU64: UInt64? { let o = _accessor.offset(VTOFFSET.maybeU64.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var defaultU64: UInt64 { let o = _accessor.offset(VTOFFSET.defaultU64.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var justF32: Float32 { let o = _accessor.offset(VTOFFSET.justF32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var maybeF32: Float32? { let o = _accessor.offset(VTOFFSET.maybeF32.v); return o == 0 ? nil : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var defaultF32: Float32 { let o = _accessor.offset(VTOFFSET.defaultF32.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var justF64: Double { let o = _accessor.offset(VTOFFSET.justF64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+    public var maybeF64: Double? { let o = _accessor.offset(VTOFFSET.maybeF64.v); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) }
+    public var defaultF64: Double { let o = _accessor.offset(VTOFFSET.defaultF64.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) }
+    public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.justEnum.v); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
+    public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VTOFFSET.maybeEnum.v); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil }
+    public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.defaultEnum.v); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one }
+    public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 36) }
+    public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VTOFFSET.justI8.p) }
+    public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VTOFFSET.maybeI8.p) }
+    public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VTOFFSET.defaultI8.p) }
+    public static func add(justU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU8, def: 0, at: VTOFFSET.justU8.p) }
+    public static func add(maybeU8: UInt8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU8, at: VTOFFSET.maybeU8.p) }
+    public static func add(defaultU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU8, def: 42, at: VTOFFSET.defaultU8.p) }
+    public static func add(justI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI16, def: 0, at: VTOFFSET.justI16.p) }
+    public static func add(maybeI16: Int16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI16, at: VTOFFSET.maybeI16.p) }
+    public static func add(defaultI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI16, def: 42, at: VTOFFSET.defaultI16.p) }
+    public static func add(justU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU16, def: 0, at: VTOFFSET.justU16.p) }
+    public static func add(maybeU16: UInt16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU16, at: VTOFFSET.maybeU16.p) }
+    public static func add(defaultU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU16, def: 42, at: VTOFFSET.defaultU16.p) }
+    public static func add(justI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI32, def: 0, at: VTOFFSET.justI32.p) }
+    public static func add(maybeI32: Int32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI32, at: VTOFFSET.maybeI32.p) }
+    public static func add(defaultI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI32, def: 42, at: VTOFFSET.defaultI32.p) }
+    public static func add(justU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU32, def: 0, at: VTOFFSET.justU32.p) }
+    public static func add(maybeU32: UInt32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU32, at: VTOFFSET.maybeU32.p) }
+    public static func add(defaultU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU32, def: 42, at: VTOFFSET.defaultU32.p) }
+    public static func add(justI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI64, def: 0, at: VTOFFSET.justI64.p) }
+    public static func add(maybeI64: Int64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI64, at: VTOFFSET.maybeI64.p) }
+    public static func add(defaultI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI64, def: 42, at: VTOFFSET.defaultI64.p) }
+    public static func add(justU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU64, def: 0, at: VTOFFSET.justU64.p) }
+    public static func add(maybeU64: UInt64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU64, at: VTOFFSET.maybeU64.p) }
+    public static func add(defaultU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU64, def: 42, at: VTOFFSET.defaultU64.p) }
+    public static func add(justF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF32, def: 0.0, at: VTOFFSET.justF32.p) }
+    public static func add(maybeF32: Float32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF32, at: VTOFFSET.maybeF32.p) }
+    public static func add(defaultF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF32, def: 42.0, at: VTOFFSET.defaultF32.p) }
+    public static func add(justF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF64, def: 0.0, at: VTOFFSET.justF64.p) }
+    public static func add(maybeF64: Double?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF64, at: VTOFFSET.maybeF64.p) }
+    public static func add(defaultF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF64, def: 42.0, at: VTOFFSET.defaultF64.p) }
+    public static func add(justBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justBool, def: false,
+     at: VTOFFSET.justBool.p) }
+    public static func add(maybeBool: Bool?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeBool, at: VTOFFSET.maybeBool.p) }
+    public static func add(defaultBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultBool, def: true,
+     at: VTOFFSET.defaultBool.p) }
+    public static func add(justEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justEnum.rawValue, def: 0, at: VTOFFSET.justEnum.p) }
+    public static func add(maybeEnum: optional_scalars_OptionalByte?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeEnum?.rawValue, at: VTOFFSET.maybeEnum.p) }
+    public static func add(defaultEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultEnum.rawValue, def: 1, at: VTOFFSET.defaultEnum.p) }
+    public static func endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createScalarStuff(
+        _ fbb: inout FlatBufferBuilder,
+        justI8: Int8 = 0,
+        maybeI8: Int8? = nil,
+        defaultI8: Int8 = 42,
+        justU8: UInt8 = 0,
+        maybeU8: UInt8? = nil,
+        defaultU8: UInt8 = 42,
+        justI16: Int16 = 0,
+        maybeI16: Int16? = nil,
+        defaultI16: Int16 = 42,
+        justU16: UInt16 = 0,
+        maybeU16: UInt16? = nil,
+        defaultU16: UInt16 = 42,
+        justI32: Int32 = 0,
+        maybeI32: Int32? = nil,
+        defaultI32: Int32 = 42,
+        justU32: UInt32 = 0,
+        maybeU32: UInt32? = nil,
+        defaultU32: UInt32 = 42,
+        justI64: Int64 = 0,
+        maybeI64: Int64? = nil,
+        defaultI64: Int64 = 42,
+        justU64: UInt64 = 0,
+        maybeU64: UInt64? = nil,
+        defaultU64: UInt64 = 42,
+        justF32: Float32 = 0.0,
+        maybeF32: Float32? = nil,
+        defaultF32: Float32 = 42.0,
+        justF64: Double = 0.0,
+        maybeF64: Double? = nil,
+        defaultF64: Double = 42.0,
+        justBool: Bool = false,
+        maybeBool: Bool? = nil,
+        defaultBool: Bool = true,
+        justEnum: optional_scalars_OptionalByte = .none_,
+        maybeEnum: optional_scalars_OptionalByte? = nil,
+        defaultEnum: optional_scalars_OptionalByte = .one
+    ) -> Offset<UOffset> {
+        let __start = optional_scalars_ScalarStuff.startScalarStuff(&fbb)
+        optional_scalars_ScalarStuff.add(justI8: justI8, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI8: maybeI8, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI8: defaultI8, &fbb)
+        optional_scalars_ScalarStuff.add(justU8: justU8, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU8: maybeU8, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU8: defaultU8, &fbb)
+        optional_scalars_ScalarStuff.add(justI16: justI16, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI16: maybeI16, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI16: defaultI16, &fbb)
+        optional_scalars_ScalarStuff.add(justU16: justU16, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU16: maybeU16, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU16: defaultU16, &fbb)
+        optional_scalars_ScalarStuff.add(justI32: justI32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI32: maybeI32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI32: defaultI32, &fbb)
+        optional_scalars_ScalarStuff.add(justU32: justU32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU32: maybeU32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU32: defaultU32, &fbb)
+        optional_scalars_ScalarStuff.add(justI64: justI64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI64: maybeI64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI64: defaultI64, &fbb)
+        optional_scalars_ScalarStuff.add(justU64: justU64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU64: maybeU64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU64: defaultU64, &fbb)
+        optional_scalars_ScalarStuff.add(justF32: justF32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeF32: maybeF32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultF32: defaultF32, &fbb)
+        optional_scalars_ScalarStuff.add(justF64: justF64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeF64: maybeF64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultF64: defaultF64, &fbb)
+        optional_scalars_ScalarStuff.add(justBool: justBool, &fbb)
+        optional_scalars_ScalarStuff.add(maybeBool: maybeBool, &fbb)
+        optional_scalars_ScalarStuff.add(defaultBool: defaultBool, &fbb)
+        optional_scalars_ScalarStuff.add(justEnum: justEnum, &fbb)
+        optional_scalars_ScalarStuff.add(maybeEnum: maybeEnum, &fbb)
+        optional_scalars_ScalarStuff.add(defaultEnum: defaultEnum, &fbb)
+        return optional_scalars_ScalarStuff.endScalarStuff(&fbb, start: __start)
+    }
+}
+
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift
new file mode 100644
index 0000000..10f2448
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift
@@ -0,0 +1,336 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+
+import FlatBuffers
+
+public enum Character: UInt8, Enum { 
+    public typealias T = UInt8
+    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+    public var value: UInt8 { return self.rawValue }
+    case none_ = 0
+    case mulan = 1
+    case rapunzel = 2
+    case belle = 3
+    case bookfan = 4
+    case other = 5
+    case unused = 6
+    
+
+    public static var max: Character { return .unused }
+    public static var min: Character { return .none_ }
+}
+
+public struct CharacterUnion {
+    public var type: Character
+    public var value: NativeTable?
+    public init(_ v: NativeTable?, type: Character) {
+        self.type = type
+        self.value = v
+    }
+    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+        switch type {
+        case .mulan:
+            var __obj = value as? AttackerT
+            return Attacker.pack(&builder, obj: &__obj)
+        case .rapunzel:
+            var __obj = value as? RapunzelT
+            return Rapunzel.pack(&builder, obj: &__obj)
+        case .belle:
+            var __obj = value as? BookReaderT
+            return BookReader.pack(&builder, obj: &__obj)
+        case .bookfan:
+            var __obj = value as? BookReaderT
+            return BookReader.pack(&builder, obj: &__obj)
+        default: return Offset()
+        }
+    }
+}
+public struct Rapunzel: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 4
+    public static var alignment = 4
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var hairLength: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+    @discardableResult public func mutate(hairLength: Int32) -> Bool { return _accessor.mutate(hairLength, index: 0) }
+    
+
+    public mutating func unpack() -> RapunzelT {
+        return RapunzelT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout RapunzelT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout RapunzelT) -> Offset<UOffset> {
+        return createRapunzel(builder: &builder, hairLength: obj.hairLength)
+    }
+}
+
+public class RapunzelT: NativeTable {
+
+    public var hairLength: Int32
+
+    public init(_ _t: inout Rapunzel) {
+        hairLength = _t.hairLength
+    }
+
+    public init() {
+        hairLength = 0
+    }
+
+}
+public struct BookReader: Readable {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 4
+    public static var alignment = 4
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+    public var booksRead: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+    @discardableResult public func mutate(booksRead: Int32) -> Bool { return _accessor.mutate(booksRead, index: 0) }
+    
+
+    public mutating func unpack() -> BookReaderT {
+        return BookReaderT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReaderT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReaderT) -> Offset<UOffset> {
+        return createBookReader(builder: &builder, booksRead: obj.booksRead)
+    }
+}
+
+public class BookReaderT: NativeTable {
+
+    public var booksRead: Int32
+
+    public init(_ _t: inout BookReader) {
+        booksRead = _t.booksRead
+    }
+
+    public init() {
+        booksRead = 0
+    }
+
+}
+extension Rapunzel {
+    @discardableResult
+    public static func createRapunzel(builder: inout FlatBufferBuilder, hairLength: Int32 = 0) -> Offset<UOffset> {
+        builder.createStructOf(size: Rapunzel.size, alignment: Rapunzel.alignment)
+        builder.reverseAdd(v: hairLength, postion: 0)
+        return builder.endStruct()
+    }
+
+}
+
+extension BookReader {
+    @discardableResult
+    public static func createBookReader(builder: inout FlatBufferBuilder, booksRead: Int32 = 0) -> Offset<UOffset> {
+        builder.createStructOf(size: BookReader.size, alignment: BookReader.alignment)
+        builder.reverseAdd(v: booksRead, postion: 0)
+        return builder.endStruct()
+    }
+
+}
+
+public struct Attacker: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
+    public static func getRootAsAttacker(bb: ByteBuffer) -> Attacker { return Attacker(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case swordAttackDamage = 4
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var swordAttackDamage: Int32 { let o = _accessor.offset(VTOFFSET.swordAttackDamage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    @discardableResult public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.swordAttackDamage.v);  return _accessor.mutate(swordAttackDamage, index: o) }
+    public static func startAttacker(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VTOFFSET.swordAttackDamage.p) }
+    public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createAttacker(
+        _ fbb: inout FlatBufferBuilder,
+        swordAttackDamage: Int32 = 0
+    ) -> Offset<UOffset> {
+        let __start = Attacker.startAttacker(&fbb)
+        Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
+        return Attacker.endAttacker(&fbb, start: __start)
+    }
+    
+
+    public mutating func unpack() -> AttackerT {
+        return AttackerT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT) -> Offset<UOffset> {
+        let __root = Attacker.startAttacker(&builder)
+        Attacker.add(swordAttackDamage: obj.swordAttackDamage, &builder)
+        return Attacker.endAttacker(&builder, start: __root)
+    }
+}
+
+public class AttackerT: NativeTable {
+
+    public var swordAttackDamage: Int32
+
+    public init(_ _t: inout Attacker) {
+        swordAttackDamage = _t.swordAttackDamage
+    }
+
+    public init() {
+        swordAttackDamage = 0
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
+
+}
+public struct Movie: FlatBufferObject, ObjectAPI {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
+    public static func getRootAsMovie(bb: ByteBuffer) -> Movie { return Movie(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    private enum VTOFFSET: VOffset {
+        case mainCharacterType = 4
+        case mainCharacter = 6
+        case charactersType = 8
+        case characters = 10
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var mainCharacterType: Character { let o = _accessor.offset(VTOFFSET.mainCharacterType.v); return o == 0 ? .none_ : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+    public func mainCharacter<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.mainCharacter.v); return o == 0 ? nil : _accessor.union(o) }
+    public var charactersTypeCount: Int32 { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func charactersType(at index: Int32) -> Character? { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? Character.none_ : Character(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
+    public var charactersCount: Int32 { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func characters<T: FlatBufferObject>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
+    public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
+    public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
+    public static func add(mainCharacter: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
+    public static func addVectorOf(charactersType: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
+    public static func addVectorOf(characters: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
+    public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createMovie(
+        _ fbb: inout FlatBufferBuilder,
+        mainCharacterType: Character = .none_,
+        offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
+        vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
+        vectorOfCharacters characters: Offset<UOffset> = Offset()
+    ) -> Offset<UOffset> {
+        let __start = Movie.startMovie(&fbb)
+        Movie.add(mainCharacterType: mainCharacterType, &fbb)
+        Movie.add(mainCharacter: mainCharacter, &fbb)
+        Movie.addVectorOf(charactersType: charactersType, &fbb)
+        Movie.addVectorOf(characters: characters, &fbb)
+        return Movie.endMovie(&fbb, start: __start)
+    }
+    
+
+    public mutating func unpack() -> MovieT {
+        return MovieT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT?) -> Offset<UOffset> {
+        guard var obj = obj else { return Offset<UOffset>() }
+        return pack(&builder, obj: &obj)
+    }
+
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT) -> Offset<UOffset> {
+        let __mainCharacter = obj.mainCharacter?.pack(builder: &builder) ?? Offset()
+        var __characters__: [Offset<UOffset>] = []
+        for i in obj.characters {
+            guard let off = i?.pack(builder: &builder) else { continue }
+            __characters__.append(off)
+        }
+        let __characters = builder.createVector(ofOffsets: __characters__)
+        let __charactersType = builder.createVector(obj.characters.compactMap { $0?.type })
+        let __root = Movie.startMovie(&builder)
+        if let o = obj.mainCharacter?.type {
+          Movie.add(mainCharacterType: o, &builder)
+          Movie.add(mainCharacter: __mainCharacter, &builder)
+        }
+
+        Movie.addVectorOf(charactersType: __charactersType, &builder)
+        Movie.addVectorOf(characters: __characters, &builder)
+        return Movie.endMovie(&builder, start: __root)
+    }
+}
+
+public class MovieT: NativeTable {
+
+    public var mainCharacter: CharacterUnion?
+    public var characters: [CharacterUnion?]
+
+    public init(_ _t: inout Movie) {
+        switch _t.mainCharacterType {
+        case .mulan:
+            var _v = _t.mainCharacter(type: Attacker.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .mulan)
+        case .rapunzel:
+            var _v = _t.mainCharacter(type: Rapunzel.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .rapunzel)
+        case .belle:
+            var _v = _t.mainCharacter(type: BookReader.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
+        case .bookfan:
+            var _v = _t.mainCharacter(type: BookReader.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
+        default: break
+        }
+        characters = []
+        for index in 0..<_t.charactersCount {
+            switch _t.charactersType(at: index) {
+            case .mulan:
+                var _v = _t.characters(at: index, type: Attacker.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .mulan))
+            case .rapunzel:
+                var _v = _t.characters(at: index, type: Rapunzel.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .rapunzel))
+            case .belle:
+                var _v = _t.characters(at: index, type: BookReader.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .belle))
+            case .bookfan:
+                var _v = _t.characters(at: index, type: BookReader.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .bookfan))
+            default: break
+            }
+        }
+    }
+
+    public init() {
+        characters = []
+    }
+
+    public func serialize() -> ByteBuffer { return serialize(type: Movie.self) }
+
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/LinuxMain.swift b/tests/FlatBuffers.Test.Swift/Tests/LinuxMain.swift
new file mode 100644
index 0000000..1b16a78
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/LinuxMain.swift
@@ -0,0 +1,8 @@
+import XCTest
+
+import FlatBuffers_Test_SwiftTests
+
+var tests = [XCTestCaseEntry]()
+tests += FlatBuffers_Test_SwiftTests.__allTests()
+
+XCTMain(tests)
diff --git a/tests/FlatBuffers.Test.Swift/monsterdata_test.mon b/tests/FlatBuffers.Test.Swift/monsterdata_test.mon
new file mode 100644
index 0000000..ba6cf27
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/monsterdata_test.mon
Binary files differ