diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
index f37f2b8..9f02d8d 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,39 +26,49 @@
 class FlatBuffersMonsterWriterTests: XCTestCase {
 
   func testData() {
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
     let _data = ByteBuffer(data: data)
-    readMonster(fb: _data)
+    readVerifiedMonster(fb: _data)
   }
 
   func testReadFromOtherLanguages() {
     let path = FileManager.default.currentDirectoryPath
-    let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent("monsterdata_test").appendingPathExtension("mon")
+    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)
+    readVerifiedMonster(fb: _data)
   }
 
   func testCreateMonster() {
     let bytes = createMonster(withPrefix: false)
+    // swiftformat:disable all
     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)
+    // swiftformat:enable all
+    let monster = MyGame_Example_Monster.getRootAsMonster(bb: bytes.buffer)
+    readMonster(monster: monster)
     mutateMonster(fb: bytes.buffer)
-    readMonster(fb: bytes.buffer)
+    readMonster(monster: monster)
   }
 
   func testCreateMonsterResizedBuffer() {
     let bytes = createMonster(withPrefix: false)
+    // swiftformat:disable all
     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)
+    // swiftformat:enable all
+    readVerifiedMonster(fb: bytes.sizedBuffer)
   }
 
   func testCreateMonsterPrefixed() {
     let bytes = createMonster(withPrefix: true)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
 
-    let newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes.buffer)
-    readMonster(fb: newBuf)
+    var buffer = bytes.buffer
+    readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
   }
 
   func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
@@ -77,7 +87,15 @@
     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(
+      pos: MyGame_Example_Vec3(
+        x: 10,
+        y: 0,
+        z: 0,
+        test1: 0,
+        test2: .blue,
+        test3: .init()),
+      &fbb)
     Monster.add(name: name, &fbb)
     let root = Monster.endMonster(&fbb, start: mStart)
     fbb.finish(offset: root)
@@ -88,31 +106,70 @@
   }
 
   func testReadMonsterFromUnsafePointerWithoutCopying() {
+    // swiftformat:disable all
     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
-    }
+    // swiftformat:enable all
+    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)
+  func testArrayOfBools() {
+    let boolArray = [false, true, false, true, false, true, false]
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let name = fbb.create(string: "Frodo")
+    let bools = fbb.createVector(boolArray)
+    let root = Monster.createMonster(
+      &fbb,
+      nameOffset: name,
+      testarrayofboolsVectorOffset: bools)
+    fbb.finish(offset: root)
+    let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)
+
+    let values = monster.testarrayofbools
+
+    XCTAssertEqual(boolArray, values)
+
+    for i in 0..<monster.testarrayofboolsCount {
+      XCTAssertEqual(boolArray[Int(i)], monster.testarrayofbools(at: i))
+    }
+  }
+
+  func readVerifiedMonster(fb: ByteBuffer) {
+    var byteBuffer = fb
+    XCTAssertNoThrow(
+      try readMonster(
+        monster: getCheckedRoot(
+          byteBuffer: &byteBuffer) as MyGame_Example_Monster))
+  }
+
+  func readMonster(monster: Monster) {
+    var monster = monster
     readFlatbufferMonster(monster: &monster)
     let unpacked: MyGame_Example_MonsterT? = monster.unpack()
     readObjectApi(monster: unpacked!)
-    guard let buffer = unpacked?.serialize() else { fatalError("Couldnt generate bytebuffer") }
+    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 names = [
+      fbb.create(string: "Frodo"),
+      fbb.create(string: "Barney"),
+      fbb.create(string: "Wilma"),
+    ]
+    var offsets: [Offset] = []
     let start1 = Monster.startMonster(&fbb)
     Monster.add(name: names[0], &fbb)
     offsets.append(Monster.endMonster(&fbb, start: start1))
@@ -136,16 +193,22 @@
     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 test4 = fbb.createVector(ofStructs: [
+      MyGame_Example_Test(a: 30, b: 40),
+      MyGame_Example_Test(a: 10, b: 20),
+    ])
 
     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(
+      pos: MyGame_Example_Vec3(
+        x: 1,
+        y: 2,
+        z: 3,
+        test1: 3,
+        test2: .green,
+        test3: .init(a: 5, b: 6)),
+      &fbb)
     Monster.add(hp: 80, &fbb)
     Monster.add(name: str, &fbb)
     Monster.addVectorOf(inventory: inv, &fbb)
@@ -190,7 +253,7 @@
     XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
     XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
 
-    let vec = monster.pos
+    let vec = monster.mutablePos
     XCTAssertEqual(vec?.x, 1)
     XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
     XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
@@ -228,6 +291,7 @@
     }
     XCTAssertEqual(sum, 10)
     XCTAssertEqual(monster.test4Count, 2)
+
     let test0 = monster.test4(at: 0)
     let test1 = monster.test4(at: 1)
     var sum0 = 0
@@ -239,6 +303,19 @@
       sum1 = Int(a) + Int(b)
     }
     XCTAssertEqual(sum0 + sum1, 100)
+
+    let mutableTest0 = monster.mutableTest4(at: 0)
+    let mutableTest1 = monster.mutableTest4(at: 1)
+    var sum2 = 0
+    var sum3 = 0
+    if let a = mutableTest0?.a, let b = mutableTest0?.b {
+      sum2 = Int(a) + Int(b)
+    }
+    if let a = mutableTest1?.a, let b = mutableTest1?.b {
+      sum3 = Int(a) + Int(b)
+    }
+    XCTAssertEqual(sum2 + sum3, 100)
+
     XCTAssertEqual(monster.testarrayofstringCount, 2)
     XCTAssertEqual(monster.testarrayofstring(at: 0), "test1")
     XCTAssertEqual(monster.testarrayofstring(at: 1), "test2")
@@ -295,4 +372,24 @@
     XCTAssertEqual(sum0 + sum1, 100)
     XCTAssertEqual(monster.testbool, true)
   }
+
+  func testEncoding() {
+    let fbb = createMonster(withPrefix: false)
+    var sizedBuffer = fbb.sizedBuffer
+    do {
+      let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      let data = try encoder.encode(reader)
+      XCTAssertEqual(data, jsonData.data(using: .utf8))
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+  var jsonData: String {
+    """
+    {\"hp\":80,\"inventory\":[0,1,2,3,4],\"test\":{\"name\":\"Fred\"},\"testarrayofstring\":[\"test1\",\"test2\"],\"testarrayoftables\":[{\"name\":\"Barney\"},{\"name\":\"Frodo\"},{\"name\":\"Wilma\"}],\"test4\":[{\"a\":30,\"b\":40},{\"a\":10,\"b\":20}],\"testbool\":true,\"test_type\":\"Monster\",\"pos\":{\"y\":2,\"test3\":{\"a\":5,\"b\":6},\"z\":3,\"x\":1,\"test1\":3,\"test2\":\"Green\"},\"name\":\"MyMonster\"}
+    """
+  }
 }
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift
index 2c344f0..2032589 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersStructsTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,12 +22,13 @@
   func testWritingAndMutatingBools() {
     var fbb = FlatBufferBuilder()
     let start = TestMutatingBool.startTestMutatingBool(&fbb)
-    TestMutatingBool.add(b: createProperty(builder: &fbb), &fbb)
+    TestMutatingBool.add(b: Property(property: false), &fbb)
     let root = TestMutatingBool.endTestMutatingBool(&fbb, start: start)
     fbb.finish(offset: root)
 
-    let testMutatingBool = TestMutatingBool.getRootAsTestMutatingBool(bb: fbb.sizedBuffer)
-    let property = testMutatingBool.b
+    let testMutatingBool = TestMutatingBool
+      .getRootAsTestMutatingBool(bb: fbb.sizedBuffer)
+    let property = testMutatingBool.mutableB
     XCTAssertEqual(property?.property, false)
     property?.mutate(property: false)
     XCTAssertEqual(property?.property, false)
@@ -37,23 +38,8 @@
 
 }
 
-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 { __p.readBuffer(of: Float32.self, at: 0)}
-  var y: Float32 { __p.readBuffer(of: Float32.self, at: 4)}
-  var z: Float32 { __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()
+struct Vec: NativeStruct {
+  var x: Float32
+  var y: Float32
+  var z: Float32
 }
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
index a605600..379e733 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,8 +24,8 @@
   func testEndian() { XCTAssertEqual(isLitteEndian, true) }
 
   func testOffset() {
-    let o = Offset<Int>()
-    let b = Offset<Int>(offset: 1)
+    let o = Offset()
+    let b = Offset(offset: 1)
     XCTAssertEqual(o.isEmpty, true)
     XCTAssertEqual(b.isEmpty, false)
   }
@@ -52,22 +52,36 @@
 
   func testCreateFinish() {
     var b = FlatBufferBuilder(initialSize: 16)
-    let countryOff = Country.createCountry(builder: &b, name: country, log: 200, lan: 100)
+    let countryOff = Country.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
     b.finish(offset: countryOff)
+    // swiftformat:disable all
     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]
+    // swiftformat:enable all
     XCTAssertEqual(b.sizedByteArray, v)
   }
 
   func testCreateFinishWithPrefix() {
     var b = FlatBufferBuilder(initialSize: 16)
-    let countryOff = Country.createCountry(builder: &b, name: country, log: 200, lan: 100)
+    let countryOff = Country.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
     b.finish(offset: countryOff, addPrefix: true)
+    // swiftformat:disable all
     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]
+    // swiftformat:enable all
     XCTAssertEqual(b.sizedByteArray, v)
   }
 
   func testReadCountry() {
+    // swiftformat:disable all
     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]
+    // swiftformat:enable all
     let buffer = ByteBuffer(bytes: v)
     let c = Country.getRootAsCountry(buffer)
     XCTAssertEqual(c.lan, 100)
@@ -94,7 +108,8 @@
       justEnum: .one,
       maybeEnum: nil)
     b.finish(offset: root)
-    let scalarTable = optional_scalars_ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
+    let scalarTable = optional_scalars_ScalarStuff
+      .getRootAsScalarStuff(bb: b.sizedBuffer)
     XCTAssertEqual(scalarTable.justI8, 80)
     XCTAssertNil(scalarTable.maybeI8)
     XCTAssertEqual(scalarTable.maybeBool, true)
@@ -115,14 +130,21 @@
     __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 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]? { __t.getVector(at: 4) }
-  var name: String? { let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+  var name: String? {
+    let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
 
   @inlinable
   static func getRootAsCountry(_ bb: ByteBuffer) -> Country {
-    Country(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    Country(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
   }
 
   @inlinable
@@ -130,17 +152,21 @@
     builder: inout FlatBufferBuilder,
     name: String,
     log: Int32,
-    lan: Int32) -> Offset<Country>
+    lan: Int32) -> Offset
   {
-    createCountry(builder: &builder, offset: builder.create(string: name), log: log, lan: lan)
+    createCountry(
+      builder: &builder,
+      offset: builder.create(string: name),
+      log: log,
+      lan: lan)
   }
 
   @inlinable
   static func createCountry(
     builder: inout FlatBufferBuilder,
-    offset: Offset<String>,
+    offset: Offset,
     log: Int32,
-    lan: Int32) -> Offset<Country>
+    lan: Int32) -> Offset
   {
     let _start = builder.startTable(with: 3)
     Country.add(builder: &builder, lng: log)
@@ -150,7 +176,10 @@
   }
 
   @inlinable
-  static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Country> {
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
     Offset(offset: builder.endTable(at: startOffset))
   }
 
@@ -160,7 +189,7 @@
   }
 
   @inlinable
-  static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
     builder.add(offset: name, at: Country.offsets.name)
   }
 
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
index 0802272..eb8a10c 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,7 +34,9 @@
       equippedOffset: weapon.o)
     b.finish(offset: root)
     let buffer = b.sizedByteArray
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
     let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer))
     XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg)
     XCTAssertEqual(monster.weapon(at: 0)?.name, str)
@@ -49,19 +51,22 @@
     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 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 path = builder.createVector(ofStructs: [
+      Vec(x: 4.0, y: 5.0, z: 6.0),
+      Vec(x: 1.0, y: 2.0, z: 3.0),
+    ])
     let orc = FinalMonster.createMonster(
       builder: &builder,
-      position: createVecWrite(builder: &builder, x: 1.0, y: 2.0, z: 3.0),
+      position: Vec(x: 1, y: 2, z: 3),
       hp: 300,
       name: name,
       inventory: inv,
@@ -71,7 +76,9 @@
       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])
+    // swiftformat:disable all
+    XCTAssertEqual(builder.sizedByteArray, [32, 0, 0, 0, 0, 0, 26, 0, 48, 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])
+    // swiftformat:enable all
   }
 
   func testEnumVector() {
@@ -83,7 +90,9 @@
     ColorsNameSpace.Monster.add(colors: off, &builder)
     let end = ColorsNameSpace.Monster.endMonster(&builder, start: start)
     builder.finish(offset: end)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
     let monster = ColorsNameSpace.Monster.getRootAsMonster(bb: builder.buffer)
     XCTAssertEqual(monster.colorsCount, 2)
     XCTAssertEqual(monster.colors(at: 0), .blue)
@@ -101,13 +110,16 @@
     let characterType: [Character] = [.belle, .mulan, .bookfan]
 
     let characters = [
-      BookReader.createBookReader(builder: &fb, booksRead: 7),
+      fb.create(struct: BookReader(booksRead: 7)),
       attack,
-      BookReader.createBookReader(builder: &fb, booksRead: 2),
+      fb.create(struct: BookReader(booksRead: 2)),
     ]
     let types = fb.createVector(characterType)
     let characterVector = fb.createVector(ofOffsets: characters)
-    let end = Movie.createMovie(&fb, vectorOfCharactersType: types, vectorOfCharacters: characterVector)
+    let end = Movie.createMovie(
+      &fb,
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
     Movie.finish(&fb, end: end)
 
     var movie = Movie.getRootAsMovie(bb: fb.buffer)
@@ -118,22 +130,125 @@
       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)
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(
+      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage,
+      swordDmg)
+    XCTAssertEqual(
+      movie.characters(at: 2, type: BookReader_Mutable.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)
+    XCTAssertEqual(
+      movie.charactersTypeCount,
+      Int32(objc?.characters.count ?? 0))
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      (objc?.characters[0]?.value as? BookReader)?.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)
+    XCTAssertEqual(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      movie.characters(at: 0, type: BookReader_Mutable.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_Mutable.self)?.booksRead,
+      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead)
+  }
+
+  func testStringUnion() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+    let stringOffset = fb.create(string: string)
+    let characterType: [Character] = [.bookfan, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+
+    let end = Movie.createMovie(
+      &fb,
+      mainCharacterType: .other,
+      mainCharacterOffset: Offset(offset: stringOffset.o),
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+
+    var movie = Movie.getRootAsMovie(bb: fb.sizedBuffer)
+    XCTAssertEqual(movie.mainCharacter(type: String.self), string)
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(movie.characters(at: 1, type: String.self), string)
+
+    var objc: MovieT? = movie.unpack()
+    XCTAssertEqual(objc?.mainCharacter?.value as? String, string)
+    XCTAssertEqual((objc?.characters[0]?.value as? BookReader)?.booksRead, 7)
+    XCTAssertEqual(objc?.characters[1]?.value as? String, string)
+    fb.clear()
+    let newMovie = Movie.pack(&fb, obj: &objc)
+    fb.finish(offset: newMovie)
+
+    let packedMovie = Movie.getRootAsMovie(bb: fb.buffer)
+    XCTAssertEqual(packedMovie.mainCharacter(type: String.self), string)
+    XCTAssertEqual(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(packedMovie.characters(at: 1, type: String.self), string)
+  }
+
+  func testEncoding() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+
+    let stringOffset = fb.create(string: string)
+
+    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, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      attack,
+      fb.create(struct: BookReader(booksRead: 2)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+    let end = Movie.createMovie(
+      &fb,
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+
+    var sizedBuffer = fb.sizedBuffer
+    do {
+      let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      let data = try encoder.encode(reader)
+      XCTAssertEqual(data, jsonData.data(using: .utf8))
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+  var jsonData: String {
+    "{\"characters_type\":[\"Belle\",\"MuLan\",\"BookFan\",\"Other\"],\"characters\":[{\"books_read\":7},{\"sword_attack_damage\":8},{\"books_read\":2},\"Awesome \\\\\\\\t\\t\\nstring!\"]}"
   }
 }
 
@@ -152,20 +267,32 @@
     private var _accessor: Table
     static func getRootAsMonster(bb: ByteBuffer) -> Monster { Monster(Table(
       bb: bb,
-      position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+      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(
+    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, _ 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 }
+    static func endMonster(
+      _ fbb: inout FlatBufferBuilder,
+      start: UOffset)
+      -> Offset
+    { let end = Offset(offset: fbb.endTable(at: start)); return end
+    }
   }
 }
 
@@ -179,24 +306,27 @@
   @inlinable
   static func createMonster(
     builder: inout FlatBufferBuilder,
-    position: Offset<UOffset>,
+    position: Vec,
     hp: Int16,
-    name: Offset<String>,
-    inventory: Offset<UOffset>,
+    name: Offset,
+    inventory: Offset,
     color: Color3,
-    weapons: Offset<UOffset>,
+    weapons: Offset,
     equipment: Equipment = .none,
-    equippedOffset: Offset<Weapon>,
-    path: Offset<UOffset>) -> Offset<LocalMonster>
+    equippedOffset: Offset,
+    path: Offset) -> Offset
   {
     let start = builder.startTable(with: 11)
-    builder.add(structOffset: 4)
+    builder.create(struct: position, position: 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(
+      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))
@@ -210,29 +340,35 @@
   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 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 {
-    LocalMonster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    LocalMonster(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
   }
 
   @inlinable
   static func createMonster(
     builder: inout FlatBufferBuilder,
-    offset: Offset<UOffset>,
+    offset: Offset,
     equipment: Equipment = .none,
-    equippedOffset: UOffset) -> Offset<LocalMonster>
+    equippedOffset: UOffset) -> Offset
   {
     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)
+    builder.add(
+      element: equipment.rawValue,
+      def: Equipment.none.rawValue,
+      at: 6)
     return Offset(offset: builder.endTable(at: start))
   }
 }
@@ -247,17 +383,22 @@
   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 dmg: Int16 { let o = __t.offset(6); return o == 0 ? 0 : __t.readBuffer(
+    of: Int16.self,
+    at: o) }
   var nameVector: [UInt8]? { __t.getVector(at: 4) }
-  var name: String? { let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+  var name: String? {
+    let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
 
-  static func assign(_ i: Int32, _ bb: ByteBuffer) -> Weapon { Weapon(Table(bb: bb, position: i)) }
+  static func assign(_ i: Int32, _ bb: ByteBuffer) -> Weapon { Weapon(Table(
+    bb: bb,
+    position: i)) }
 
   @inlinable
   static func createWeapon(
     builder: inout FlatBufferBuilder,
-    offset: Offset<String>,
-    dmg: Int16) -> Offset<Weapon>
+    offset: Offset,
+    dmg: Int16) -> Offset
   {
     let _start = builder.startTable(with: 2)
     Weapon.add(builder: &builder, name: offset)
@@ -266,12 +407,15 @@
   }
 
   @inlinable
-  static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Weapon> {
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
     Offset(offset: builder.endTable(at: startOffset))
   }
 
   @inlinable
-  static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
     builder.add(offset: name, at: Weapon.offsets.name)
   }
 
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift
index f095eef..4cb245f 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersVectorsTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,12 +25,22 @@
     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 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)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
   }
 
   func testCreateIntArray() {
@@ -38,7 +48,9 @@
     var b = FlatBufferBuilder(initialSize: 20)
     let o = b.createVector(numbers, size: numbers.count)
     b.finish(offset: o)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
   }
 
   func testCreateEmptyIntArray() {
@@ -54,7 +66,9 @@
     var b = FlatBufferBuilder(initialSize: 20)
     let o = b.createVector(ofStrings: strs)
     b.finish(offset: o)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
   }
   func testCreateSharedStringVector() {
     let norway = "Norway"
@@ -67,7 +81,9 @@
     let v = [noStr, deStr, _noStr, _deStr]
     let end = b.createVector(ofOffsets: v)
     b.finish(offset: end)
+    // swiftformat:disable all
     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])
+    // swiftformat:enable all
   }
 
   func testReadInt32Array() {
@@ -101,7 +117,9 @@
 
   @inlinable
   static func getRootAsNumbers(_ bb: ByteBuffer) -> Numbers {
-    Numbers(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: 0))))
+    Numbers(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
   }
 
   var vArrayInt: [Int]? { __t.getVector(at: 4) }
@@ -109,23 +127,35 @@
   var vArrayDouble: [Double]? { __t.getVector(at: 4) }
   var vArrayFloat: [Float32]? { __t.getVector(at: 4) }
 
-  static func createNumbersVector(b: inout FlatBufferBuilder, array: [Int]) -> Offset<UOffset> {
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Int]) -> Offset
+  {
     b.createVector(array, size: array.count)
   }
 
-  static func createNumbersVector(b: inout FlatBufferBuilder, array: [Int32]) -> Offset<UOffset> {
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Int32]) -> Offset
+  {
     b.createVector(array, size: array.count)
   }
 
-  static func createNumbersVector(b: inout FlatBufferBuilder, array: [Double]) -> Offset<UOffset> {
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Double]) -> Offset
+  {
     b.createVector(array, size: array.count)
   }
 
-  static func createNumbersVector(b: inout FlatBufferBuilder, array: [Float32]) -> Offset<UOffset> {
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Float32]) -> Offset
+  {
     b.createVector(array, size: array.count)
   }
 
-  static func createNumbers(b: inout FlatBufferBuilder, o: Offset<UOffset>) -> Offset<UOffset> {
+  static func createNumbers(b: inout FlatBufferBuilder, o: Offset) -> Offset {
     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
index 4d6d724..a6e1cb0 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersDoubleTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersDoubleTests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,17 +23,39 @@
 
   func testCreateFinish() {
     var b = FlatBufferBuilder(initialSize: 16)
-    let countryOff = CountryDouble.createCountry(builder: &b, name: country, log: 200, lan: 100)
+    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]
+    // swiftformat:disable all
+    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
+    ]
+    // swiftformat:enable all
     XCTAssertEqual(b.sizedByteArray, v)
   }
 
   func testCreateFinishWithPrefix() {
     var b = FlatBufferBuilder(initialSize: 16)
-    let countryOff = CountryDouble.createCountry(builder: &b, name: country, log: 200, lan: 100)
+    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]
+    // swiftformat:disable all
+    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
+    ]
+    // swiftformat:enable all
     XCTAssertEqual(b.sizedByteArray, v)
   }
 }
@@ -55,16 +77,20 @@
     builder: inout FlatBufferBuilder,
     name: String,
     log: Double,
-    lan: Double) -> Offset<Country>
+    lan: Double) -> Offset
   {
-    createCountry(builder: &builder, offset: builder.create(string: name), log: log, lan: lan)
+    createCountry(
+      builder: &builder,
+      offset: builder.create(string: name),
+      log: log,
+      lan: lan)
   }
 
   static func createCountry(
     builder: inout FlatBufferBuilder,
-    offset: Offset<String>,
+    offset: Offset,
     log: Double,
-    lan: Double) -> Offset<Country>
+    lan: Double) -> Offset
   {
     let _start = builder.startTable(with: 3)
     CountryDouble.add(builder: &builder, lng: log)
@@ -73,7 +99,10 @@
     return CountryDouble.end(builder: &builder, startOffset: _start)
   }
 
-  static func end(builder: inout FlatBufferBuilder, startOffset: UOffset) -> Offset<Country> {
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
     Offset(offset: builder.endTable(at: startOffset))
   }
 
@@ -81,7 +110,7 @@
     add(builder: &builder, name: builder.create(string: name))
   }
 
-  static func add(builder: inout FlatBufferBuilder, name: Offset<String>) {
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
     builder.add(offset: name, at: Country.offsets.name)
   }
 
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift
new file mode 100644
index 0000000..cd97f25
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import XCTest
+@testable import FlatBuffers
+
+class FlatBuffersMoreDefaults: XCTestCase {
+
+  func testFlatbuffersObject() {
+    var fbb = FlatBufferBuilder()
+    let root = MoreDefaults.createMoreDefaults(&fbb)
+    fbb.finish(offset: root)
+    let defaults = MoreDefaults.getRootAsMoreDefaults(bb: fbb.sizedBuffer)
+    XCTAssertEqual(defaults.emptyString, "")
+    XCTAssertEqual(defaults.someString, "some")
+    XCTAssertEqual(defaults.ints, [])
+    XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.bools, [])
+    XCTAssertEqual(defaults.intsCount, 0)
+    XCTAssertEqual(defaults.floatsCount, 0)
+    XCTAssertEqual(defaults.abcsCount, 0)
+    XCTAssertEqual(defaults.boolsCount, 0)
+  }
+
+  func testFlatbuffersObjectAPI() {
+    var fbb = FlatBufferBuilder()
+    let defaults = MoreDefaultsT()
+    XCTAssertEqual(defaults.emptyString, "")
+    XCTAssertEqual(defaults.someString, "some")
+    XCTAssertEqual(defaults.ints, [])
+    XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.abcs, [])
+    XCTAssertEqual(defaults.bools, [])
+
+    let buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self)
+    let fDefaults = MoreDefaults.getRootAsMoreDefaults(bb: buffer)
+    XCTAssertEqual(fDefaults.emptyString, "")
+    XCTAssertEqual(fDefaults.someString, "some")
+    XCTAssertEqual(fDefaults.ints, [])
+    XCTAssertEqual(fDefaults.floats, [])
+    XCTAssertEqual(fDefaults.intsCount, 0)
+    XCTAssertEqual(fDefaults.floatsCount, 0)
+    XCTAssertEqual(fDefaults.abcsCount, 0)
+    XCTAssertEqual(fDefaults.boolsCount, 0)
+  }
+
+  func testEncoding() {
+    var fbb = FlatBufferBuilder()
+    let root = MoreDefaults.createMoreDefaults(&fbb)
+    fbb.finish(offset: root)
+    var sizedBuffer = fbb.sizedBuffer
+    do {
+      let reader: MoreDefaults = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      let data = try encoder.encode(reader)
+      XCTAssertEqual(data, jsonData.data(using: .utf8))
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+  var jsonData: String {
+    "{\"empty_string\":\"\",\"some_string\":\"some\"}"
+  }
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersVerifierTests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersVerifierTests.swift
new file mode 100644
index 0000000..750f97b
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersVerifierTests.swift
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import XCTest
+@testable import FlatBuffers
+
+final class FlatbuffersVerifierTests: XCTestCase {
+
+  lazy var validStorage: ByteBuffer.Storage = ByteBuffer.Storage(
+    count: Int(FlatBufferMaxSize) - 1,
+    alignment: 1)
+  lazy var errorStorage: ByteBuffer.Storage = ByteBuffer.Storage(
+    count: Int(FlatBufferMaxSize) + 1,
+    alignment: 1)
+
+  var buffer: ByteBuffer!
+
+  var validFlatbuffersObject: ByteBuffer!
+  var invalidFlatbuffersObject: ByteBuffer!
+
+  override func setUp() {
+    // swiftformat:disable all
+    buffer = ByteBuffer(initialSize: 32)
+    add(buffer: &buffer, v: 4, p: 16)
+    add(buffer: &buffer, v: 4, p: 20)
+
+    validFlatbuffersObject = ByteBuffer(bytes: [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])
+
+    invalidFlatbuffersObject = ByteBuffer(bytes: [0, 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])
+
+    // swiftformat:enable all
+  }
+
+  func testVeriferInitPassing() {
+    var buffer = ByteBuffer(initialSize: 0)
+    buffer._storage = validStorage
+    XCTAssertNoThrow(try Verifier(buffer: &buffer))
+  }
+
+  func testVeriferInitFailing() {
+    var buffer = ByteBuffer(initialSize: 0)
+    buffer._storage = errorStorage
+    XCTAssertThrowsError(try Verifier(buffer: &buffer))
+  }
+
+  func testVerifierCheckAlignment() {
+    var verifier = try! Verifier(buffer: &buffer)
+    do {
+      try verifier.isAligned(position: 20, type: Int.self)
+    } catch {
+      XCTAssertEqual(
+        error as? FlatbuffersErrors,
+        .missAlignedPointer(position: 20, type: "Int"))
+    }
+    XCTAssertNoThrow(try verifier.isAligned(position: 16, type: Int.self))
+
+    var newVerifer = try! Verifier(buffer: &buffer, checkAlignment: false)
+    XCTAssertNoThrow(try newVerifer.isAligned(position: 16, type: Int.self))
+  }
+
+  func testRangeInBuffer() {
+    var verifier = try! Verifier(buffer: &buffer)
+    let size = MemoryLayout<Int64>.size
+    XCTAssertNoThrow(try verifier.rangeInBuffer(position: 24, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 30, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 32, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 34, size: size))
+
+    verifier = try! Verifier(
+      buffer: &buffer,
+      options: .init(maxDepth: 0, maxTableCount: 0, maxApparentSize: 4))
+    do {
+      try verifier.rangeInBuffer(position: 24, size: size)
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .apparentSizeTooLarge)
+    }
+  }
+
+  func testPositionInBuffer() {
+    var verifier = try! Verifier(buffer: &buffer)
+    XCTAssertNoThrow(try verifier.inBuffer(position: 0, of: Int64.self))
+    XCTAssertNoThrow(try verifier.inBuffer(position: 24, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: -9, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 25, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int32.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 30, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 32, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 34, of: Int64.self))
+  }
+
+  func testVisitTable() {
+    var verifier = try! Verifier(buffer: &validFlatbuffersObject)
+    XCTAssertNoThrow(try verifier.visitTable(at: 48))
+    verifier.reset()
+  }
+
+  func testTableVerifier() {
+    var verifier = try! Verifier(buffer: &validFlatbuffersObject)
+
+    var tableVerifer = try! verifier.visitTable(at: 48)
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 4,
+      fieldName: "Vec",
+      required: false,
+      type: Vec3.self))
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 8,
+      fieldName: "hp",
+      required: false,
+      type: Int16.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 10,
+      fieldName: "name",
+      required: true,
+      type: ForwardOffset<String>.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 14,
+      fieldName: "inventory",
+      required: false,
+      type: ForwardOffset<Vector<UInt8, UInt8>>.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 22,
+      fieldName: "test4",
+      required: false,
+      type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
+        .self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 24,
+      fieldName: "Vector of strings",
+      required: false,
+      type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self))
+
+    do {
+      try tableVerifer.visit(
+        field: 13,
+        fieldName: "notvalid",
+        required: false,
+        type: Int16.self)
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .missAlignedPointer(position: 25, type: "UInt16"))
+    }
+
+    do {
+      try tableVerifer.visit(
+        unionKey: 18,
+        unionField: 20,
+        unionKeyName: "testType",
+        fieldName: "test",
+        required: false,
+        completion: { (verifier, key: MyGame_Example_Any_, pos) in
+          switch key {
+          case .none_:
+            break
+          case .monster:
+            try ForwardOffset<MyGame_Example_Monster>.verify(
+              &verifier,
+              at: pos,
+              of: MyGame_Example_Monster.self)
+
+          case .testsimpletablewithenum:
+            break
+          case .mygameExample2Monster:
+            break
+          }
+        })
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .missAlignedPointer(position: 25, type: "UInt16"))
+    }
+  }
+
+  func testVerifyUnionVectors() {
+    // swiftformat:disable all
+    var byteBuffer = ByteBuffer(bytes: [20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, 20, 0, 0, 0, 3, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 3, 0, 0, 0, 3, 1, 4, 0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0])
+    // swiftformat:enable all
+    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &byteBuffer) as Movie)
+  }
+
+  func testFullVerifier() {
+    XCTAssertNoThrow(
+      try getCheckedRoot(
+        byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster)
+  }
+
+  func testInvalidBuffer() {
+    XCTAssertThrowsError(
+      try getCheckedRoot(
+        byteBuffer: &invalidFlatbuffersObject) as MyGame_Example_Monster)
+  }
+
+  func testValidUnionBuffer() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+    let stringOffset = fb.create(string: string)
+    let characterType: [Character] = [.bookfan, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+
+    let end = Movie.createMovie(
+      &fb,
+      mainCharacterType: .other,
+      mainCharacterOffset: Offset(offset: stringOffset.o),
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+    var buf = fb.sizedBuffer
+    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &buf) as Movie)
+  }
+
+  func add(buffer: inout ByteBuffer, v: Int32, p: Int) {
+    buffer.write(value: v, index: p)
+  }
+}
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
index d51f3d9..155080a 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/MutatingBool_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/MutatingBool_generated.swift
@@ -1,47 +1,153 @@
 // automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
 
 import FlatBuffers
 
-public struct Property: Readable {
+public struct Property: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-    static func validateVersion() { FlatBuffersVersion_1_12_0() }
-    public var __buffer: ByteBuffer! { return _accessor.bb }
-    private var _accessor: Struct
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-    public static var size = 1
-    public static var alignment = 1
-    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+  private var _property: Bool
 
-    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 init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _property = _accessor.readBuffer(of: Bool.self, at: 0)
+  }
+
+  public init(property: Bool) {
+    _property = property
+  }
+
+  public init() {
+    _property = false
+  }
+
+  public init(_ _t: inout Property_Mutable) {
+    _property = _t.property
+  }
+
+  public var property: Bool { _property }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: Property.self)
+  }
 }
 
-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()
-}
+extension Property: Encodable {
 
-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 }
+  enum CodingKeys: String, CodingKey {
+    case property = "property"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if property != false {
+      try container.encodeIfPresent(property, forKey: .property)
     }
-
-    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 }
+  }
 }
 
+public struct Property_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  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 mutating func unpack() -> Property {
+    return Property(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Property?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Property) -> Offset {
+    return builder.create(struct: obj)
+  }
+}
+
+public struct TestMutatingBool: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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) }
+
+  private 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 : _accessor.readBuffer(of: Property.self, at: o) }
+  public var mutableB: Property_Mutable? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : Property_Mutable(_accessor.bb, o: o + _accessor.postion) }
+  public static func startTestMutatingBool(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(b: Property?, _ fbb: inout FlatBufferBuilder) { guard let b = b else { return }; fbb.create(struct: b, position: VTOFFSET.b.p) }
+  public static func endTestMutatingBool(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createTestMutatingBool(
+    _ fbb: inout FlatBufferBuilder,
+    b: Property? = nil
+  ) -> Offset {
+    let __start = TestMutatingBool.startTestMutatingBool(&fbb)
+    TestMutatingBool.add(b: b, &fbb)
+    return TestMutatingBool.endTestMutatingBool(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> TestMutatingBoolT {
+    return TestMutatingBoolT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout TestMutatingBoolT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout TestMutatingBoolT) -> Offset {
+    let __root = TestMutatingBool.startTestMutatingBool(&builder)
+    TestMutatingBool.add(b: obj.b, &builder)
+    return TestMutatingBool.endTestMutatingBool(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.b.p, fieldName: "b", required: false, type: Property.self)
+    _v.finish()
+  }
+}
+
+extension TestMutatingBool: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case b = "b"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(b, forKey: .b)
+  }
+}
+
+public class TestMutatingBoolT: NativeObject {
+
+  public var b: Property?
+
+  public init(_ _t: inout TestMutatingBool) {
+    b = _t.b
+  }
+
+  public init() {
+    b = Property()
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: TestMutatingBool.self) }
+
+}
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift
index 8459ee5..4134762 100644
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/XCTestManifests.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,6 +32,7 @@
   //   `swift test --generate-linuxmain`
   // to regenerate.
   static let __allTests__FlatBuffersMonsterWriterTests = [
+    ("testArrayOfBools", testArrayOfBools),
     ("testCreateMonster", testCreateMonster),
     ("testCreateMonsterPrefixed", testCreateMonsterPrefixed),
     ("testCreateMonsterResizedBuffer", testCreateMonsterResizedBuffer),
@@ -49,6 +50,16 @@
   ]
 }
 
+extension FlatBuffersMoreDefaults {
+  // DO NOT MODIFY: This is autogenerated, use:
+  //   `swift test --generate-linuxmain`
+  // to regenerate.
+  static let __allTests__FlatBuffersMoreDefaults = [
+    ("testFlatbuffersObject", testFlatbuffersObject),
+    ("testFlatbuffersObjectAPI", testFlatbuffersObjectAPI),
+  ]
+}
+
 extension FlatBuffersStructsTests {
   // DO NOT MODIFY: This is autogenerated, use:
   //   `swift test --generate-linuxmain`
@@ -83,6 +94,7 @@
     ("testCreateMonstor", testCreateMonstor),
     ("testEndTableFinish", testEndTableFinish),
     ("testEnumVector", testEnumVector),
+    ("testStringUnion", testStringUnion),
     ("testUnionVector", testUnionVector),
   ]
 }
@@ -102,14 +114,37 @@
   ]
 }
 
+extension FlatbuffersVerifierTests {
+  // DO NOT MODIFY: This is autogenerated, use:
+  //   `swift test --generate-linuxmain`
+  // to regenerate.
+  static let __allTests__FlatbuffersVerifierTests = [
+    ("testFullVerifier", testFullVerifier),
+    ("testInvalidBuffer", testInvalidBuffer),
+    ("testPositionInBuffer", testPositionInBuffer),
+    ("testRangeInBuffer", testRangeInBuffer),
+    ("testTableVerifier", testTableVerifier),
+    ("testValidUnionBuffer", testValidUnionBuffer),
+    ("testVeriferInitFailing", testVeriferInitFailing),
+    ("testVeriferInitPassing", testVeriferInitPassing),
+    ("testVerifierCheckAlignment", testVerifierCheckAlignment),
+    ("testVerifyUnionVectors", testVerifyUnionVectors),
+    ("testVisitTable", testVisitTable),
+  ]
+}
+
 public func __allTests() -> [XCTestCaseEntry] {
   [
     testCase(FlatBuffersDoubleTests.__allTests__FlatBuffersDoubleTests),
-    testCase(FlatBuffersMonsterWriterTests.__allTests__FlatBuffersMonsterWriterTests),
+    testCase(
+      FlatBuffersMonsterWriterTests
+        .__allTests__FlatBuffersMonsterWriterTests),
+    testCase(FlatBuffersMoreDefaults.__allTests__FlatBuffersMoreDefaults),
     testCase(FlatBuffersStructsTests.__allTests__FlatBuffersStructsTests),
     testCase(FlatBuffersTests.__allTests__FlatBuffersTests),
     testCase(FlatBuffersUnionTests.__allTests__FlatBuffersUnionTests),
     testCase(FlatBuffersVectors.__allTests__FlatBuffersVectors),
+    testCase(FlatbuffersVerifierTests.__allTests__FlatbuffersVerifierTests),
   ]
 }
 #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
index 414a816..b5fd535 100644
--- 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
@@ -24,41 +24,121 @@
 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 protocol MyGame_Example_MonsterStorageClientProtocol: GRPCClient {
+
+  var serviceName: String { get }
+
+  var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? { get }
+
+  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 {
+extension MyGame_Example_MonsterStorageClientProtocol {
+
+  public var serviceName: String { "MyGame.Example.MonsterStorage" }
+
+  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,
+      interceptors: self.interceptors?.makeStoreInterceptors() ?? []
+    )
+  }
+
+  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,
+      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
+      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,
+      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? []
+    )
+  }
+
+  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,
+      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+public protocol MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when invoking 'Store'.
+  func makeStoreInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when invoking 'Retrieve'.
+  func makeRetrieveInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
+
+  /// - Returns: Interceptors to use when invoking 'GetMaxHitPoint'.
+  func makeGetMaxHitPointInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when invoking 'GetMinMaxHitPoints'.
+  func makeGetMinMaxHitPointsInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+}
+
+public final class MyGame_Example_MonsterStorageServiceClient: MyGame_Example_MonsterStorageClientProtocol {
   public let channel: GRPCChannel
   public var defaultCallOptions: CallOptions
+  public var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol?
 
-  public init(channel: GRPCChannel, defaultCallOptions: CallOptions = CallOptions()) {
+  public init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? = nil
+  ) {
     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)
+    self.interceptors = interceptors
   }
 }
 
 public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
-  func Store(_ request: Message<MyGame_Example_Monster>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<MyGame_Example_Stat>>
+  var interceptors: MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol? { get }
+  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>
@@ -68,30 +148,61 @@
 
   var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
 
-  func handleMethod(_ methodName: Substring, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
-    switch methodName {
+  func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
+    switch name {
     case "Store":
-    return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { context in
-      return { request in
-        self.Store(request, context: context)
-      }
-    }
+    return UnaryServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeStoreInterceptors() ?? [],
+      userFunction: self.Store(request:context:))
+
     case "Retrieve":
-    return CallHandlerFactory.makeServerStreaming(callHandlerContext: callHandlerContext) { context in
-      return { request in
-        self.Retrieve(request: request, context: context)
-      }
-    }
+    return ServerStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Stat>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Monster>>(),
+      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
+      userFunction: self.Retrieve(request:context:))
+
     case "GetMaxHitPoint":
-    return CallHandlerFactory.makeClientStreaming(callHandlerContext: callHandlerContext) { context in
-      self.GetMaxHitPoint(context: context)
-    }
+    return ClientStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? [],
+      observerFactory: self.GetMaxHitPoint(context:))
+
     case "GetMinMaxHitPoints":
-    return CallHandlerFactory.makeBidirectionalStreaming(callHandlerContext: callHandlerContext) { context in
-      self.GetMinMaxHitPoints(context: context)
-    }
+    return BidirectionalStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
+      observerFactory: self.GetMinMaxHitPoints(context:))
+
     default: return nil;
     }
   }
 
 }
+
+public protocol MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when handling 'Store'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeStoreInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when handling 'Retrieve'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeRetrieveInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
+
+  /// - Returns: Interceptors to use when handling 'GetMaxHitPoint'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetMaxHitPointInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when handling 'GetMinMaxHitPoints'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetMinMaxHitPointsInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+}
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
index b15eddf..c8a0502 100644
--- 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
@@ -5,7 +5,7 @@
 import FlatBuffers
 
 ///  Composite components of Monster color.
-public enum MyGame_Example_Color: UInt8, Enum { 
+public enum MyGame_Example_Color: UInt8, Enum, Verifiable {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }
@@ -15,13 +15,23 @@
   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 { 
+extension MyGame_Example_Color: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .red: try container.encode("Red")
+    case .green: try container.encode("Green")
+    case .blue: try container.encode("Blue")
+    }
+  }
+}
+
+public enum MyGame_Example_Race: Int8, Enum, Verifiable {
   public typealias T = Int8
   public static var byteSize: Int { return MemoryLayout<Int8>.size }
   public var value: Int8 { return self.rawValue }
@@ -29,34 +39,84 @@
   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 { 
+extension MyGame_Example_Race: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("None")
+    case .human: try container.encode("Human")
+    case .dwarf: try container.encode("Dwarf")
+    case .elf: try container.encode("Elf")
+    }
+  }
+}
+
+public enum MyGame_Example_LongEnum: UInt64, Enum, Verifiable {
+  public typealias T = UInt64
+  public static var byteSize: Int { return MemoryLayout<UInt64>.size }
+  public var value: UInt64 { return self.rawValue }
+  case longone = 2
+  case longtwo = 4
+  case longbig = 1099511627776
+
+  public static var max: MyGame_Example_LongEnum { return .longbig }
+  public static var min: MyGame_Example_LongEnum { return .longone }
+}
+
+extension MyGame_Example_LongEnum: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .longone: try container.encode("LongOne")
+    case .longtwo: try container.encode("LongTwo")
+    case .longbig: try container.encode("LongBig")
+    }
+  }
+}
+
+public enum MyGame_Example_Any_: UInt8, UnionEnum {
   public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
   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_ }
 }
 
+extension MyGame_Example_Any_: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .monster: try container.encode("Monster")
+    case .testsimpletablewithenum: try container.encode("TestSimpleTableWithEnum")
+    case .mygameExample2Monster: try container.encode("MyGame_Example2_Monster")
+    }
+  }
+}
+
 public struct MyGame_Example_Any_Union {
   public var type: MyGame_Example_Any_
-  public var value: NativeTable?
-  public init(_ v: NativeTable?, type: MyGame_Example_Any_) {
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: MyGame_Example_Any_) {
     self.type = type
     self.value = v
   }
-  public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
     switch type {
     case .monster:
       var __obj = value as? MyGame_Example_MonsterT
@@ -71,28 +131,44 @@
     }
   }
 }
-public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { 
+public enum MyGame_Example_AnyUniqueAliases: UInt8, UnionEnum {
   public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
   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_ }
 }
 
+extension MyGame_Example_AnyUniqueAliases: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .m: try container.encode("M")
+    case .ts: try container.encode("TS")
+    case .m2: try container.encode("M2")
+    }
+  }
+}
+
 public struct MyGame_Example_AnyUniqueAliasesUnion {
   public var type: MyGame_Example_AnyUniqueAliases
-  public var value: NativeTable?
-  public init(_ v: NativeTable?, type: MyGame_Example_AnyUniqueAliases) {
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: MyGame_Example_AnyUniqueAliases) {
     self.type = type
     self.value = v
   }
-  public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
     switch type {
     case .m:
       var __obj = value as? MyGame_Example_MonsterT
@@ -107,28 +183,44 @@
     }
   }
 }
-public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { 
+public enum MyGame_Example_AnyAmbiguousAliases: UInt8, UnionEnum {
   public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
   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_ }
 }
 
+extension MyGame_Example_AnyAmbiguousAliases: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .m1: try container.encode("M1")
+    case .m2: try container.encode("M2")
+    case .m3: try container.encode("M3")
+    }
+  }
+}
+
 public struct MyGame_Example_AnyAmbiguousAliasesUnion {
   public var type: MyGame_Example_AnyAmbiguousAliases
-  public var value: NativeTable?
-  public init(_ v: NativeTable?, type: MyGame_Example_AnyAmbiguousAliases) {
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: MyGame_Example_AnyAmbiguousAliases) {
     self.type = type
     self.value = v
   }
-  public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
     switch type {
     case .m1:
       var __obj = value as? MyGame_Example_MonsterT
@@ -143,14 +235,66 @@
     }
   }
 }
-public struct MyGame_Example_Test: Readable {
+public struct MyGame_Example_Test: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+
+  private var _a: Int16
+  private var _b: Int8
+  private let padding0__: UInt8 = 0
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _a = _accessor.readBuffer(of: Int16.self, at: 0)
+    _b = _accessor.readBuffer(of: Int8.self, at: 2)
+  }
+
+  public init(a: Int16, b: Int8) {
+    _a = a
+    _b = b
+  }
+
+  public init() {
+    _a = 0
+    _b = 0
+  }
+
+  public init(_ _t: inout MyGame_Example_Test_Mutable) {
+    _a = _t.a
+    _b = _t.b
+  }
+
+  public var a: Int16 { _a }
+  public var b: Int8 { _b }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: MyGame_Example_Test.self)
+  }
+}
+
+extension MyGame_Example_Test: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case a = "a"
+    case b = "b"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if a != 0 {
+      try container.encodeIfPresent(a, forKey: .a)
+    }
+    if b != 0 {
+      try container.encodeIfPresent(b, forKey: .b)
+    }
+  }
+}
+
+public struct MyGame_Example_Test_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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) }
@@ -159,43 +303,120 @@
   @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 mutating func unpack() -> MyGame_Example_Test {
+    return MyGame_Example_Test(&self)
   }
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestT?) -> Offset<UOffset> {
-    guard var obj = obj else { return Offset<UOffset>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Test?) -> Offset {
+    guard var obj = obj else { return Offset() }
     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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Test) -> Offset {
+    return builder.create(struct: obj)
   }
 }
 
-public class MyGame_Example_TestT: NativeTable {
+public struct MyGame_Example_Vec3: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  public var a: Int16
-  public var b: Int8
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-  public init(_ _t: inout MyGame_Example_Test) {
-    a = _t.a
-    b = _t.b
+  private var _x: Float32
+  private var _y: Float32
+  private var _z: Float32
+  private let padding0__: UInt32 = 0
+  private var _test1: Double
+  private var _test2: UInt8
+  private let padding1__: UInt8 = 0
+  private var _test3: MyGame_Example_Test
+  private let padding2__: UInt16 = 0
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _x = _accessor.readBuffer(of: Float32.self, at: 0)
+    _y = _accessor.readBuffer(of: Float32.self, at: 4)
+    _z = _accessor.readBuffer(of: Float32.self, at: 8)
+    _test1 = _accessor.readBuffer(of: Double.self, at: 16)
+    _test2 = _accessor.readBuffer(of: UInt8.self, at: 24)
+    _test3 = MyGame_Example_Test(_accessor.bb, o: _accessor.postion + 26)
+  }
+
+  public init(x: Float32, y: Float32, z: Float32, test1: Double, test2: MyGame_Example_Color, test3: MyGame_Example_Test) {
+    _x = x
+    _y = y
+    _z = z
+    _test1 = test1
+    _test2 = test2.value
+    _test3 = test3
   }
 
   public init() {
-    a = 0
-    b = 0
+    _x = 0.0
+    _y = 0.0
+    _z = 0.0
+    _test1 = 0.0
+    _test2 = 0
+    _test3 = MyGame_Example_Test()
   }
 
-}
-public struct MyGame_Example_Vec3: Readable {
+  public init(_ _t: inout MyGame_Example_Vec3_Mutable) {
+    _x = _t.x
+    _y = _t.y
+    _z = _t.z
+    _test1 = _t.test1
+    _test2 = _t.test2.value
+    var _vtest3 = _t.test3
+    _test3 = _vtest3.unpack()
+  }
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  public var x: Float32 { _x }
+  public var y: Float32 { _y }
+  public var z: Float32 { _z }
+  public var test1: Double { _test1 }
+  public var test2: MyGame_Example_Color { MyGame_Example_Color(rawValue: _test2)! }
+  public var test3: MyGame_Example_Test { _test3 }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: MyGame_Example_Vec3.self)
+  }
+}
+
+extension MyGame_Example_Vec3: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case x = "x"
+    case y = "y"
+    case z = "z"
+    case test1 = "test1"
+    case test2 = "test2"
+    case test3 = "test3"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if x != 0.0 {
+      try container.encodeIfPresent(x, forKey: .x)
+    }
+    if y != 0.0 {
+      try container.encodeIfPresent(y, forKey: .y)
+    }
+    if z != 0.0 {
+      try container.encodeIfPresent(z, forKey: .z)
+    }
+    if test1 != 0.0 {
+      try container.encodeIfPresent(test1, forKey: .test1)
+    }
+    if test2 != .red {
+      try container.encodeIfPresent(test2, forKey: .test2)
+    }
+    try container.encodeIfPresent(test3, forKey: .test3)
+  }
+}
+
+public struct MyGame_Example_Vec3_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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) }
@@ -207,59 +428,82 @@
   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) }
+  @discardableResult public func mutate(test2: MyGame_Example_Color) -> Bool { return _accessor.mutate(test2.rawValue, index: 24) }
+  public var test3: MyGame_Example_Test_Mutable { return MyGame_Example_Test_Mutable(_accessor.bb, o: _accessor.postion + 26) }
   
 
-  public mutating func unpack() -> MyGame_Example_Vec3T {
-    return MyGame_Example_Vec3T(&self)
+  public mutating func unpack() -> MyGame_Example_Vec3 {
+    return MyGame_Example_Vec3(&self)
   }
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3T?) -> Offset<UOffset> {
-    guard var obj = obj else { return Offset<UOffset>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3?) -> Offset {
+    guard var obj = obj else { return Offset() }
     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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3) -> Offset {
+    return builder.create(struct: obj)
   }
 }
 
-public class MyGame_Example_Vec3T: NativeTable {
+public struct MyGame_Example_Ability: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  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
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-  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()
+  private var _id: UInt32
+  private var _distance: UInt32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _id = _accessor.readBuffer(of: UInt32.self, at: 0)
+    _distance = _accessor.readBuffer(of: UInt32.self, at: 4)
+  }
+
+  public init(id: UInt32, distance: UInt32) {
+    _id = id
+    _distance = distance
   }
 
   public init() {
-    x = 0.0
-    y = 0.0
-    z = 0.0
-    test1 = 0.0
-    test2 = .red
-    test3 = MyGame_Example_TestT()
+    _id = 0
+    _distance = 0
   }
 
-}
-public struct MyGame_Example_Ability: Readable {
+  public init(_ _t: inout MyGame_Example_Ability_Mutable) {
+    _id = _t.id
+    _distance = _t.distance
+  }
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  public var id: UInt32 { _id }
+  public var distance: UInt32 { _distance }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: MyGame_Example_Ability.self)
+  }
+}
+
+extension MyGame_Example_Ability: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case id = "id"
+    case distance = "distance"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if id != 0 {
+      try container.encodeIfPresent(id, forKey: .id)
+    }
+    if distance != 0 {
+      try container.encodeIfPresent(distance, forKey: .distance)
+    }
+  }
+}
+
+public struct MyGame_Example_Ability_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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) }
@@ -268,104 +512,147 @@
   @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 mutating func unpack() -> MyGame_Example_Ability {
+    return MyGame_Example_Ability(&self)
   }
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_AbilityT?) -> Offset<UOffset> {
-    guard var obj = obj else { return Offset<UOffset>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Ability?) -> Offset {
+    guard var obj = obj else { return Offset() }
     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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Ability) -> Offset {
+    return builder.create(struct: obj)
   }
 }
 
-public class MyGame_Example_AbilityT: NativeTable {
+public struct MyGame_Example_StructOfStructs: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  public var id: UInt32
-  public var distance: UInt32
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-  public init(_ _t: inout MyGame_Example_Ability) {
-    id = _t.id
-    distance = _t.distance
+  private var _a: MyGame_Example_Ability
+  private var _b: MyGame_Example_Test
+  private var _c: MyGame_Example_Ability
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _a = MyGame_Example_Ability(_accessor.bb, o: _accessor.postion + 0)
+    _b = MyGame_Example_Test(_accessor.bb, o: _accessor.postion + 8)
+    _c = MyGame_Example_Ability(_accessor.bb, o: _accessor.postion + 12)
+  }
+
+  public init(a: MyGame_Example_Ability, b: MyGame_Example_Test, c: MyGame_Example_Ability) {
+    _a = a
+    _b = b
+    _c = c
   }
 
   public init() {
-    id = 0
-    distance = 0
+    _a = MyGame_Example_Ability()
+    _b = MyGame_Example_Test()
+    _c = MyGame_Example_Ability()
   }
 
-}
-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()
+  public init(_ _t: inout MyGame_Example_StructOfStructs_Mutable) {
+    var _va = _t.a
+    _a = _va.unpack()
+    var _vb = _t.b
+    _b = _vb.unpack()
+    var _vc = _t.c
+    _c = _vc.unpack()
   }
 
+  public var a: MyGame_Example_Ability { _a }
+  public var b: MyGame_Example_Test { _b }
+  public var c: MyGame_Example_Ability { _c }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: MyGame_Example_StructOfStructs.self)
+  }
 }
 
-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_StructOfStructs: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case a = "a"
+    case b = "b"
+    case c = "c"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(a, forKey: .a)
+    try container.encodeIfPresent(b, forKey: .b)
+    try container.encodeIfPresent(c, forKey: .c)
+  }
+}
+
+public struct MyGame_Example_StructOfStructs_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var a: MyGame_Example_Ability_Mutable { return MyGame_Example_Ability_Mutable(_accessor.bb, o: _accessor.postion + 0) }
+  public var b: MyGame_Example_Test_Mutable { return MyGame_Example_Test_Mutable(_accessor.bb, o: _accessor.postion + 8) }
+  public var c: MyGame_Example_Ability_Mutable { return MyGame_Example_Ability_Mutable(_accessor.bb, o: _accessor.postion + 12) }
+  
+
+  public mutating func unpack() -> MyGame_Example_StructOfStructs {
+    return MyGame_Example_StructOfStructs(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructs?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
   }
 
-}
-
-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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructs) -> Offset {
+    return builder.create(struct: obj)
   }
-
 }
 
-public struct MyGame_InParentNamespace: FlatBufferObject, ObjectAPI {
+public struct MyGame_InParentNamespace: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 static func endInParentNamespace(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT) -> Offset {
     let __root = MyGame_InParentNamespace.startInParentNamespace(&builder)
     return MyGame_InParentNamespace.endInParentNamespace(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    _v.finish()
+  }
 }
 
-public class MyGame_InParentNamespaceT: NativeTable {
+extension MyGame_InParentNamespace: Encodable {
+
+  public func encode(to encoder: Encoder) throws {
+  }
+}
+
+public class MyGame_InParentNamespaceT: NativeObject {
 
 
   public init(_ _t: inout MyGame_InParentNamespace) {
@@ -377,37 +664,48 @@
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
 
 }
-public struct MyGame_Example2_Monster: FlatBufferObject, ObjectAPI {
+public struct MyGame_Example2_Monster: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT) -> Offset {
     let __root = MyGame_Example2_Monster.startMonster(&builder)
     return MyGame_Example2_Monster.endMonster(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    _v.finish()
+  }
 }
 
-public class MyGame_Example2_MonsterT: NativeTable {
+extension MyGame_Example2_Monster: Encodable {
+
+  public func encode(to encoder: Encoder) throws {
+  }
+}
+
+public class MyGame_Example2_MonsterT: NativeObject {
 
 
   public init(_ _t: inout MyGame_Example2_Monster) {
@@ -419,13 +717,13 @@
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
 
 }
-internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, ObjectAPI {
+internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -441,11 +739,11 @@
   @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 endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   internal static func createTestSimpleTableWithEnum(
     _ fbb: inout FlatBufferBuilder,
     color: MyGame_Example_Color = .green
-  ) -> Offset<UOffset> {
+  ) -> Offset {
     let __start = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&fbb)
     MyGame_Example_TestSimpleTableWithEnum.add(color: color, &fbb)
     return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&fbb, start: __start)
@@ -455,19 +753,38 @@
   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>() }
+  internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset<UOffset> {
+  internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset {
     let __root = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&builder)
     MyGame_Example_TestSimpleTableWithEnum.add(color: obj.color, &builder)
     return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.color.p, fieldName: "color", required: false, type: MyGame_Example_Color.self)
+    _v.finish()
+  }
 }
 
-internal class MyGame_Example_TestSimpleTableWithEnumT: NativeTable {
+extension MyGame_Example_TestSimpleTableWithEnum: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case color = "color"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if color != .green {
+      try container.encodeIfPresent(color, forKey: .color)
+    }
+  }
+}
+
+internal class MyGame_Example_TestSimpleTableWithEnumT: NativeObject {
 
   internal var color: MyGame_Example_Color
 
@@ -482,13 +799,13 @@
   internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
 
 }
-public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPI {
+public struct MyGame_Example_Stat: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -509,38 +826,62 @@
   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(id: Offset, _ 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 endStat(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createStat(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfId id: Offset<String> = Offset(),
+    idOffset id: Offset = Offset(),
     val: Int64 = 0,
     count: UInt16 = 0
-  ) -> Offset<UOffset> {
+  ) -> Offset {
     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 static func sortVectorOfStat(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
+    var off = offsets
+    off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 8, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 8, fbb: fbb.buffer), fbb: fbb.buffer) < 0 } 
+    return fbb.createVector(ofOffsets: off)
+  }
+  fileprivate static func lookupByKey(vector: Int32, key: UInt16, fbb: ByteBuffer) -> MyGame_Example_Stat? {
+    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: UInt16.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 8, fbb: fbb)))
+      if comp > 0 {
+        span = middle
+      } else if comp < 0 {
+        middle += 1
+        start += middle
+        span -= middle
+      } else {
+        return MyGame_Example_Stat(fbb, o: tableOffset)
+      }
+    }
+    return nil
+  }
   
 
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT) -> Offset<UOffset> {
-    let __id: Offset<String>
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT) -> Offset {
+    let __id: Offset
     if let s = obj.id {
       __id = builder.create(string: s)
     } else {
-      __id = Offset<String>()
+      __id = Offset()
     }
 
     let __root = MyGame_Example_Stat.startStat(&builder)
@@ -549,9 +890,36 @@
     MyGame_Example_Stat.add(count: obj.count, &builder)
     return MyGame_Example_Stat.endStat(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.id.p, fieldName: "id", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.val.p, fieldName: "val", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.count.p, fieldName: "count", required: false, type: UInt16.self)
+    _v.finish()
+  }
 }
 
-public class MyGame_Example_StatT: NativeTable {
+extension MyGame_Example_Stat: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case id = "id"
+    case val = "val"
+    case count = "count"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(id, forKey: .id)
+    if val != 0 {
+      try container.encodeIfPresent(val, forKey: .val)
+    }
+    if count != 0 {
+      try container.encodeIfPresent(count, forKey: .count)
+    }
+  }
+}
+
+public class MyGame_Example_StatT: NativeObject {
 
   public var id: String?
   public var val: Int64
@@ -571,13 +939,13 @@
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
 
 }
-public struct MyGame_Example_Referrable: FlatBufferObject, ObjectAPI {
+public struct MyGame_Example_Referrable: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -593,16 +961,16 @@
   @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 endReferrable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createReferrable(
     _ fbb: inout FlatBufferBuilder,
     id: UInt64 = 0
-  ) -> Offset<UOffset> {
+  ) -> Offset {
     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> {
+  public static func sortVectorOfReferrable(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
     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)
@@ -631,19 +999,38 @@
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT) -> Offset {
     let __root = MyGame_Example_Referrable.startReferrable(&builder)
     MyGame_Example_Referrable.add(id: obj.id, &builder)
     return MyGame_Example_Referrable.endReferrable(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.id.p, fieldName: "id", required: false, type: UInt64.self)
+    _v.finish()
+  }
 }
 
-public class MyGame_Example_ReferrableT: NativeTable {
+extension MyGame_Example_Referrable: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case id = "id"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if id != 0 {
+      try container.encodeIfPresent(id, forKey: .id)
+    }
+  }
+}
+
+public class MyGame_Example_ReferrableT: NativeObject {
 
   public var id: UInt64
 
@@ -659,13 +1046,13 @@
 
 }
 ///  an example documentation comment: "monster object"
-public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
+public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -721,11 +1108,16 @@
     case vectorOfEnums = 98
     case signedEnum = 100
     case testrequirednestedflatbuffer = 102
+    case scalarKeySortedTables = 104
+    case nativeInline = 106
+    case longEnumNonEnumDefault = 108
+    case longEnumNormalDefault = 110
     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 pos: MyGame_Example_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_Vec3.self, at: o) }
+  public var mutablePos: MyGame_Example_Vec3_Mutable? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Example_Vec3_Mutable(_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) }
@@ -739,9 +1131,10 @@
   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 func test<T: FlatbuffersInitializable>(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 func test4(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? nil : _accessor.directRead(of: MyGame_Example_Test.self, offset: _accessor.vector(at: o) + index * 4) }
+  public func mutableTest4(at index: Int32) -> MyGame_Example_Test_Mutable? { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? nil : MyGame_Example_Test_Mutable(_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
@@ -774,9 +1167,9 @@
   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 func testarrayofbools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return o == 0 ? true : _accessor.directRead(of: Bool.self, offset: _accessor.vector(at: o) + index * 1) }
+  public var testarrayofbools: [Bool] { return _accessor.getVector(at: VTOFFSET.testarrayofbools.v) ?? [] }
+  public func mutate(testarrayofbools: Bool, 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) }
@@ -786,13 +1179,15 @@
   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 func testarrayofsortedstruct(at index: Int32) -> MyGame_Example_Ability? { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? nil : _accessor.directRead(of: MyGame_Example_Ability.self, offset: _accessor.vector(at: o) + index * 8) }
+  public func mutableTestarrayofsortedstruct(at index: Int32) -> MyGame_Example_Ability_Mutable? { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? nil : MyGame_Example_Ability_Mutable(_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 func test5(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? nil : _accessor.directRead(of: MyGame_Example_Test.self, offset: _accessor.vector(at: o) + index * 4) }
+  public func mutableTest5(at index: Int32) -> MyGame_Example_Test_Mutable? { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? nil : MyGame_Example_Test_Mutable(_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) ?? [] }
@@ -827,9 +1222,9 @@
   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 func anyUnique<T: FlatbuffersInitializable>(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 func anyAmbiguous<T: FlatbuffersInitializable>(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_ }
@@ -838,24 +1233,33 @@
   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 var scalarKeySortedTablesCount: Int32 { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func scalarKeySortedTables(at index: Int32) -> MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+  public func scalarKeySortedTablesBy(key: UInt16) -> MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? nil : MyGame_Example_Stat.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
+  public var nativeInline: MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.nativeInline.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_Test.self, at: o) }
+  public var mutableNativeInline: MyGame_Example_Test_Mutable? { let o = _accessor.offset(VTOFFSET.nativeInline.v); return o == 0 ? nil : MyGame_Example_Test_Mutable(_accessor.bb, o: o + _accessor.postion) }
+  public var longEnumNonEnumDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
+  @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v);  return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
+  public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
+  @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v);  return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
+  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 54) }
+  public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: 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(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func addVectorOf(inventory: Offset, _ 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 add(test: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test, at: VTOFFSET.test.p) }
+  public static func addVectorOf(test4: Offset, _ 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)
+    builder.startVector(size * MemoryLayout<MyGame_Example_Test>.size, elementSize: MemoryLayout<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 addVectorOf(testarrayofstring: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring, at: VTOFFSET.testarrayofstring.p) }
+  public static func addVectorOf(testarrayoftables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayoftables, at: VTOFFSET.testarrayoftables.p) }
+  public static func add(enemy: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: enemy, at: VTOFFSET.enemy.p) }
+  public static func addVectorOf(testnestedflatbuffer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testnestedflatbuffer, at: VTOFFSET.testnestedflatbuffer.p) }
+  public static func add(testempty: Offset, _ 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) }
@@ -866,40 +1270,156 @@
   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 addVectorOf(testarrayofbools: Offset, _ 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 addVectorOf(testarrayofstring2: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring2, at: VTOFFSET.testarrayofstring2.p) }
+  public static func addVectorOf(testarrayofsortedstruct: Offset, _ 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)
+    builder.startVector(size * MemoryLayout<MyGame_Example_Ability>.size, elementSize: MemoryLayout<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 addVectorOf(flex: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: flex, at: VTOFFSET.flex.p) }
+  public static func addVectorOf(test5: Offset, _ 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)
+    builder.startVector(size * MemoryLayout<MyGame_Example_Test>.size, elementSize: MemoryLayout<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 addVectorOf(vectorOfLongs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfLongs, at: VTOFFSET.vectorOfLongs.p) }
+  public static func addVectorOf(vectorOfDoubles: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfDoubles, at: VTOFFSET.vectorOfDoubles.p) }
+  public static func add(parentNamespaceTest: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: parentNamespaceTest, at: VTOFFSET.parentNamespaceTest.p) }
+  public static func addVectorOf(vectorOfReferrables: Offset, _ 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 addVectorOf(vectorOfWeakReferences: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfWeakReferences, at: VTOFFSET.vectorOfWeakReferences.p) }
+  public static func addVectorOf(vectorOfStrongReferrables: Offset, _ 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 addVectorOf(vectorOfCoOwningReferences: Offset, _ 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 addVectorOf(vectorOfNonOwningReferences: Offset, _ 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(anyUnique: Offset, _ 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(anyAmbiguous: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VTOFFSET.anyAmbiguous.p) }
+  public static func addVectorOf(vectorOfEnums: Offset, _ 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> {
+  public static func addVectorOf(testrequirednestedflatbuffer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VTOFFSET.testrequirednestedflatbuffer.p) }
+  public static func addVectorOf(scalarKeySortedTables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: scalarKeySortedTables, at: VTOFFSET.scalarKeySortedTables.p) }
+  public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
+  public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
+  public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
+  public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
+  public static func createMonster(
+    _ fbb: inout FlatBufferBuilder,
+    pos: MyGame_Example_Vec3? = nil,
+    mana: Int16 = 150,
+    hp: Int16 = 100,
+    nameOffset name: Offset = Offset(),
+    inventoryVectorOffset inventory: Offset = Offset(),
+    color: MyGame_Example_Color = .blue,
+    testType: MyGame_Example_Any_ = .none_,
+    testOffset test: Offset = Offset(),
+    test4VectorOffset test4: Offset = Offset(),
+    testarrayofstringVectorOffset testarrayofstring: Offset = Offset(),
+    testarrayoftablesVectorOffset testarrayoftables: Offset = Offset(),
+    enemyOffset enemy: Offset = Offset(),
+    testnestedflatbufferVectorOffset testnestedflatbuffer: Offset = Offset(),
+    testemptyOffset testempty: Offset = Offset(),
+    testbool: Bool = false,
+    testhashs32Fnv1: Int32 = 0,
+    testhashu32Fnv1: UInt32 = 0,
+    testhashs64Fnv1: Int64 = 0,
+    testhashu64Fnv1: UInt64 = 0,
+    testhashs32Fnv1a: Int32 = 0,
+    testhashu32Fnv1a: UInt32 = 0,
+    testhashs64Fnv1a: Int64 = 0,
+    testhashu64Fnv1a: UInt64 = 0,
+    testarrayofboolsVectorOffset testarrayofbools: Offset = Offset(),
+    testf: Float32 = 3.14159,
+    testf2: Float32 = 3.0,
+    testf3: Float32 = 0.0,
+    testarrayofstring2VectorOffset testarrayofstring2: Offset = Offset(),
+    testarrayofsortedstructVectorOffset testarrayofsortedstruct: Offset = Offset(),
+    flexVectorOffset flex: Offset = Offset(),
+    test5VectorOffset test5: Offset = Offset(),
+    vectorOfLongsVectorOffset vectorOfLongs: Offset = Offset(),
+    vectorOfDoublesVectorOffset vectorOfDoubles: Offset = Offset(),
+    parentNamespaceTestOffset parentNamespaceTest: Offset = Offset(),
+    vectorOfReferrablesVectorOffset vectorOfReferrables: Offset = Offset(),
+    singleWeakReference: UInt64 = 0,
+    vectorOfWeakReferencesVectorOffset vectorOfWeakReferences: Offset = Offset(),
+    vectorOfStrongReferrablesVectorOffset vectorOfStrongReferrables: Offset = Offset(),
+    coOwningReference: UInt64 = 0,
+    vectorOfCoOwningReferencesVectorOffset vectorOfCoOwningReferences: Offset = Offset(),
+    nonOwningReference: UInt64 = 0,
+    vectorOfNonOwningReferencesVectorOffset vectorOfNonOwningReferences: Offset = Offset(),
+    anyUniqueType: MyGame_Example_AnyUniqueAliases = .none_,
+    anyUniqueOffset anyUnique: Offset = Offset(),
+    anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases = .none_,
+    anyAmbiguousOffset anyAmbiguous: Offset = Offset(),
+    vectorOfEnumsVectorOffset vectorOfEnums: Offset = Offset(),
+    signedEnum: MyGame_Example_Race = .none_,
+    testrequirednestedflatbufferVectorOffset testrequirednestedflatbuffer: Offset = Offset(),
+    scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
+    nativeInline: MyGame_Example_Test? = nil,
+    longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
+    longEnumNormalDefault: MyGame_Example_LongEnum = .longone
+  ) -> Offset {
+    let __start = MyGame_Example_Monster.startMonster(&fbb)
+    MyGame_Example_Monster.add(pos: pos, &fbb)
+    MyGame_Example_Monster.add(mana: mana, &fbb)
+    MyGame_Example_Monster.add(hp: hp, &fbb)
+    MyGame_Example_Monster.add(name: name, &fbb)
+    MyGame_Example_Monster.addVectorOf(inventory: inventory, &fbb)
+    MyGame_Example_Monster.add(color: color, &fbb)
+    MyGame_Example_Monster.add(testType: testType, &fbb)
+    MyGame_Example_Monster.add(test: test, &fbb)
+    MyGame_Example_Monster.addVectorOf(test4: test4, &fbb)
+    MyGame_Example_Monster.addVectorOf(testarrayofstring: testarrayofstring, &fbb)
+    MyGame_Example_Monster.addVectorOf(testarrayoftables: testarrayoftables, &fbb)
+    MyGame_Example_Monster.add(enemy: enemy, &fbb)
+    MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: testnestedflatbuffer, &fbb)
+    MyGame_Example_Monster.add(testempty: testempty, &fbb)
+    MyGame_Example_Monster.add(testbool: testbool, &fbb)
+    MyGame_Example_Monster.add(testhashs32Fnv1: testhashs32Fnv1, &fbb)
+    MyGame_Example_Monster.add(testhashu32Fnv1: testhashu32Fnv1, &fbb)
+    MyGame_Example_Monster.add(testhashs64Fnv1: testhashs64Fnv1, &fbb)
+    MyGame_Example_Monster.add(testhashu64Fnv1: testhashu64Fnv1, &fbb)
+    MyGame_Example_Monster.add(testhashs32Fnv1a: testhashs32Fnv1a, &fbb)
+    MyGame_Example_Monster.add(testhashu32Fnv1a: testhashu32Fnv1a, &fbb)
+    MyGame_Example_Monster.add(testhashs64Fnv1a: testhashs64Fnv1a, &fbb)
+    MyGame_Example_Monster.add(testhashu64Fnv1a: testhashu64Fnv1a, &fbb)
+    MyGame_Example_Monster.addVectorOf(testarrayofbools: testarrayofbools, &fbb)
+    MyGame_Example_Monster.add(testf: testf, &fbb)
+    MyGame_Example_Monster.add(testf2: testf2, &fbb)
+    MyGame_Example_Monster.add(testf3: testf3, &fbb)
+    MyGame_Example_Monster.addVectorOf(testarrayofstring2: testarrayofstring2, &fbb)
+    MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: testarrayofsortedstruct, &fbb)
+    MyGame_Example_Monster.addVectorOf(flex: flex, &fbb)
+    MyGame_Example_Monster.addVectorOf(test5: test5, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfLongs: vectorOfLongs, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfDoubles: vectorOfDoubles, &fbb)
+    MyGame_Example_Monster.add(parentNamespaceTest: parentNamespaceTest, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfReferrables: vectorOfReferrables, &fbb)
+    MyGame_Example_Monster.add(singleWeakReference: singleWeakReference, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: vectorOfWeakReferences, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: vectorOfStrongReferrables, &fbb)
+    MyGame_Example_Monster.add(coOwningReference: coOwningReference, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: vectorOfCoOwningReferences, &fbb)
+    MyGame_Example_Monster.add(nonOwningReference: nonOwningReference, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: vectorOfNonOwningReferences, &fbb)
+    MyGame_Example_Monster.add(anyUniqueType: anyUniqueType, &fbb)
+    MyGame_Example_Monster.add(anyUnique: anyUnique, &fbb)
+    MyGame_Example_Monster.add(anyAmbiguousType: anyAmbiguousType, &fbb)
+    MyGame_Example_Monster.add(anyAmbiguous: anyAmbiguous, &fbb)
+    MyGame_Example_Monster.addVectorOf(vectorOfEnums: vectorOfEnums, &fbb)
+    MyGame_Example_Monster.add(signedEnum: signedEnum, &fbb)
+    MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: testrequirednestedflatbuffer, &fbb)
+    MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: scalarKeySortedTables, &fbb)
+    MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
+    MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb)
+    MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb)
+    return MyGame_Example_Monster.endMonster(&fbb, start: __start)
+  }
+  public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
     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)
@@ -929,23 +1449,23 @@
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT) -> Offset {
     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)
+      builder.create(struct: _o)
     }
-    let __test4 = builder.endVectorOfStructs(count: obj.test4.count)
+    let __test4 = builder.endVector(len: obj.test4.count)
     let __testarrayofstring = builder.createVector(ofStrings: obj.testarrayofstring.compactMap({ $0 }) )
-    var __testarrayoftables__: [Offset<UOffset>] = []
+    var __testarrayoftables__: [Offset] = []
     for var i in obj.testarrayoftables {
       __testarrayoftables__.append(MyGame_Example_Monster.pack(&builder, obj: &i))
     }
@@ -958,26 +1478,26 @@
     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)
+      builder.create(struct: _o)
     }
-    let __testarrayofsortedstruct = builder.endVectorOfStructs(count: obj.testarrayofsortedstruct.count)
+    let __testarrayofsortedstruct = builder.endVector(len: 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)
+      builder.create(struct: _o)
     }
-    let __test5 = builder.endVectorOfStructs(count: obj.test5.count)
+    let __test5 = builder.endVector(len: 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>] = []
+    var __vectorOfReferrables__: [Offset] = []
     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>] = []
+    var __vectorOfStrongReferrables__: [Offset] = []
     for var i in obj.vectorOfStrongReferrables {
       __vectorOfStrongReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
     }
@@ -988,8 +1508,13 @@
     let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
     let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
     let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
+    var __scalarKeySortedTables__: [Offset] = []
+    for var i in obj.scalarKeySortedTables {
+      __scalarKeySortedTables__.append(MyGame_Example_Stat.pack(&builder, obj: &i))
+    }
+    let __scalarKeySortedTables = builder.createVector(ofOffsets: __scalarKeySortedTables__)
     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(pos: obj.pos, &builder)
     MyGame_Example_Monster.add(mana: obj.mana, &builder)
     MyGame_Example_Monster.add(hp: obj.hp, &builder)
     MyGame_Example_Monster.add(name: __name, &builder)
@@ -1047,20 +1572,388 @@
     MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
     MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
     MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
+    MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: __scalarKeySortedTables, &builder)
+    MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
+    MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder)
+    MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder)
     return MyGame_Example_Monster.endMonster(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.pos.p, fieldName: "pos", required: false, type: MyGame_Example_Vec3.self)
+    try _v.visit(field: VTOFFSET.mana.p, fieldName: "mana", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.hp.p, fieldName: "hp", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: true, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.inventory.p, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VTOFFSET.color.p, fieldName: "color", required: false, type: MyGame_Example_Color.self)
+    try _v.visit(unionKey: VTOFFSET.testType.p, unionField: VTOFFSET.test.p, unionKeyName: "testType", fieldName: "test", required: false, completion: { (verifier, key: MyGame_Example_Any_, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .monster:
+        try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
+      case .testsimpletablewithenum:
+        try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(&verifier, at: pos, of: MyGame_Example_TestSimpleTableWithEnum.self)
+      case .mygameExample2Monster:
+        try ForwardOffset<MyGame_Example2_Monster>.verify(&verifier, at: pos, of: MyGame_Example2_Monster.self)
+      }
+    })
+    try _v.visit(field: VTOFFSET.test4.p, fieldName: "test4", required: false, type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>.self)
+    try _v.visit(field: VTOFFSET.testarrayofstring.p, fieldName: "testarrayofstring", required: false, type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self)
+    try _v.visit(field: VTOFFSET.testarrayoftables.p, fieldName: "testarrayoftables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Monster>, MyGame_Example_Monster>>.self)
+    try _v.visit(field: VTOFFSET.enemy.p, fieldName: "enemy", required: false, type: ForwardOffset<MyGame_Example_Monster>.self)
+    try _v.visit(field: VTOFFSET.testnestedflatbuffer.p, fieldName: "testnestedflatbuffer", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VTOFFSET.testempty.p, fieldName: "testempty", required: false, type: ForwardOffset<MyGame_Example_Stat>.self)
+    try _v.visit(field: VTOFFSET.testbool.p, fieldName: "testbool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.testhashs32Fnv1.p, fieldName: "testhashs32Fnv1", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.testhashu32Fnv1.p, fieldName: "testhashu32Fnv1", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.testhashs64Fnv1.p, fieldName: "testhashs64Fnv1", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.testhashu64Fnv1.p, fieldName: "testhashu64Fnv1", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.testhashs32Fnv1a.p, fieldName: "testhashs32Fnv1a", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.testhashu32Fnv1a.p, fieldName: "testhashu32Fnv1a", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.testhashs64Fnv1a.p, fieldName: "testhashs64Fnv1a", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.testhashu64Fnv1a.p, fieldName: "testhashu64Fnv1a", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.testarrayofbools.p, fieldName: "testarrayofbools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
+    try _v.visit(field: VTOFFSET.testf.p, fieldName: "testf", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.testf2.p, fieldName: "testf2", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.testf3.p, fieldName: "testf3", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.testarrayofstring2.p, fieldName: "testarrayofstring2", required: false, type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self)
+    try _v.visit(field: VTOFFSET.testarrayofsortedstruct.p, fieldName: "testarrayofsortedstruct", required: false, type: ForwardOffset<Vector<MyGame_Example_Ability, MyGame_Example_Ability>>.self)
+    try _v.visit(field: VTOFFSET.flex.p, fieldName: "flex", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VTOFFSET.test5.p, fieldName: "test5", required: false, type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>.self)
+    try _v.visit(field: VTOFFSET.vectorOfLongs.p, fieldName: "vectorOfLongs", required: false, type: ForwardOffset<Vector<Int64, Int64>>.self)
+    try _v.visit(field: VTOFFSET.vectorOfDoubles.p, fieldName: "vectorOfDoubles", required: false, type: ForwardOffset<Vector<Double, Double>>.self)
+    try _v.visit(field: VTOFFSET.parentNamespaceTest.p, fieldName: "parentNamespaceTest", required: false, type: ForwardOffset<MyGame_InParentNamespace>.self)
+    try _v.visit(field: VTOFFSET.vectorOfReferrables.p, fieldName: "vectorOfReferrables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Referrable>, MyGame_Example_Referrable>>.self)
+    try _v.visit(field: VTOFFSET.singleWeakReference.p, fieldName: "singleWeakReference", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.vectorOfWeakReferences.p, fieldName: "vectorOfWeakReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    try _v.visit(field: VTOFFSET.vectorOfStrongReferrables.p, fieldName: "vectorOfStrongReferrables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Referrable>, MyGame_Example_Referrable>>.self)
+    try _v.visit(field: VTOFFSET.coOwningReference.p, fieldName: "coOwningReference", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.vectorOfCoOwningReferences.p, fieldName: "vectorOfCoOwningReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    try _v.visit(field: VTOFFSET.nonOwningReference.p, fieldName: "nonOwningReference", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.vectorOfNonOwningReferences.p, fieldName: "vectorOfNonOwningReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    try _v.visit(unionKey: VTOFFSET.anyUniqueType.p, unionField: VTOFFSET.anyUnique.p, unionKeyName: "anyUniqueType", fieldName: "anyUnique", required: false, completion: { (verifier, key: MyGame_Example_AnyUniqueAliases, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .m:
+        try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
+      case .ts:
+        try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(&verifier, at: pos, of: MyGame_Example_TestSimpleTableWithEnum.self)
+      case .m2:
+        try ForwardOffset<MyGame_Example2_Monster>.verify(&verifier, at: pos, of: MyGame_Example2_Monster.self)
+      }
+    })
+    try _v.visit(unionKey: VTOFFSET.anyAmbiguousType.p, unionField: VTOFFSET.anyAmbiguous.p, unionKeyName: "anyAmbiguousType", fieldName: "anyAmbiguous", required: false, completion: { (verifier, key: MyGame_Example_AnyAmbiguousAliases, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .m1:
+        try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
+      case .m2:
+        try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
+      case .m3:
+        try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
+      }
+    })
+    try _v.visit(field: VTOFFSET.vectorOfEnums.p, fieldName: "vectorOfEnums", required: false, type: ForwardOffset<Vector<MyGame_Example_Color, MyGame_Example_Color>>.self)
+    try _v.visit(field: VTOFFSET.signedEnum.p, fieldName: "signedEnum", required: false, type: MyGame_Example_Race.self)
+    try _v.visit(field: VTOFFSET.testrequirednestedflatbuffer.p, fieldName: "testrequirednestedflatbuffer", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VTOFFSET.scalarKeySortedTables.p, fieldName: "scalarKeySortedTables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Stat>, MyGame_Example_Stat>>.self)
+    try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
+    try _v.visit(field: VTOFFSET.longEnumNonEnumDefault.p, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self)
+    try _v.visit(field: VTOFFSET.longEnumNormalDefault.p, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self)
+    _v.finish()
+  }
 }
 
-public class MyGame_Example_MonsterT: NativeTable {
+extension MyGame_Example_Monster: Encodable {
 
-  public var pos: MyGame_Example_Vec3T?
+  enum CodingKeys: String, CodingKey {
+    case pos = "pos"
+    case mana = "mana"
+    case hp = "hp"
+    case name = "name"
+    case inventory = "inventory"
+    case color = "color"
+    case testType = "test_type"
+    case test = "test"
+    case test4 = "test4"
+    case testarrayofstring = "testarrayofstring"
+    case testarrayoftables = "testarrayoftables"
+    case enemy = "enemy"
+    case testnestedflatbuffer = "testnestedflatbuffer"
+    case testempty = "testempty"
+    case testbool = "testbool"
+    case testhashs32Fnv1 = "testhashs32_fnv1"
+    case testhashu32Fnv1 = "testhashu32_fnv1"
+    case testhashs64Fnv1 = "testhashs64_fnv1"
+    case testhashu64Fnv1 = "testhashu64_fnv1"
+    case testhashs32Fnv1a = "testhashs32_fnv1a"
+    case testhashu32Fnv1a = "testhashu32_fnv1a"
+    case testhashs64Fnv1a = "testhashs64_fnv1a"
+    case testhashu64Fnv1a = "testhashu64_fnv1a"
+    case testarrayofbools = "testarrayofbools"
+    case testf = "testf"
+    case testf2 = "testf2"
+    case testf3 = "testf3"
+    case testarrayofstring2 = "testarrayofstring2"
+    case testarrayofsortedstruct = "testarrayofsortedstruct"
+    case flex = "flex"
+    case test5 = "test5"
+    case vectorOfLongs = "vector_of_longs"
+    case vectorOfDoubles = "vector_of_doubles"
+    case parentNamespaceTest = "parent_namespace_test"
+    case vectorOfReferrables = "vector_of_referrables"
+    case singleWeakReference = "single_weak_reference"
+    case vectorOfWeakReferences = "vector_of_weak_references"
+    case vectorOfStrongReferrables = "vector_of_strong_referrables"
+    case coOwningReference = "co_owning_reference"
+    case vectorOfCoOwningReferences = "vector_of_co_owning_references"
+    case nonOwningReference = "non_owning_reference"
+    case vectorOfNonOwningReferences = "vector_of_non_owning_references"
+    case anyUniqueType = "any_unique_type"
+    case anyUnique = "any_unique"
+    case anyAmbiguousType = "any_ambiguous_type"
+    case anyAmbiguous = "any_ambiguous"
+    case vectorOfEnums = "vector_of_enums"
+    case signedEnum = "signed_enum"
+    case testrequirednestedflatbuffer = "testrequirednestedflatbuffer"
+    case scalarKeySortedTables = "scalar_key_sorted_tables"
+    case nativeInline = "native_inline"
+    case longEnumNonEnumDefault = "long_enum_non_enum_default"
+    case longEnumNormalDefault = "long_enum_normal_default"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(pos, forKey: .pos)
+    if mana != 150 {
+      try container.encodeIfPresent(mana, forKey: .mana)
+    }
+    if hp != 100 {
+      try container.encodeIfPresent(hp, forKey: .hp)
+    }
+    try container.encodeIfPresent(name, forKey: .name)
+    if inventoryCount > 0 {
+      try container.encodeIfPresent(inventory, forKey: .inventory)
+    }
+    if color != .blue {
+      try container.encodeIfPresent(color, forKey: .color)
+    }
+    if testType != .none_ {
+      try container.encodeIfPresent(testType, forKey: .testType)
+    }
+    switch testType {
+    case .monster:
+      let _v = test(type: MyGame_Example_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .test)
+    case .testsimpletablewithenum:
+      let _v = test(type: MyGame_Example_TestSimpleTableWithEnum.self)
+      try container.encodeIfPresent(_v, forKey: .test)
+    case .mygameExample2Monster:
+      let _v = test(type: MyGame_Example2_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .test)
+    default: break;
+    }
+    if test4Count > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .test4)
+      for index in 0..<test4Count {
+        guard let type = test4(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if testarrayofstringCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .testarrayofstring)
+      for index in 0..<testarrayofstringCount {
+        guard let type = testarrayofstring(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if testarrayoftablesCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .testarrayoftables)
+      for index in 0..<testarrayoftablesCount {
+        guard let type = testarrayoftables(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    try container.encodeIfPresent(enemy, forKey: .enemy)
+    if testnestedflatbufferCount > 0 {
+      try container.encodeIfPresent(testnestedflatbuffer, forKey: .testnestedflatbuffer)
+    }
+    try container.encodeIfPresent(testempty, forKey: .testempty)
+    if testbool != false {
+      try container.encodeIfPresent(testbool, forKey: .testbool)
+    }
+    if testhashs32Fnv1 != 0 {
+      try container.encodeIfPresent(testhashs32Fnv1, forKey: .testhashs32Fnv1)
+    }
+    if testhashu32Fnv1 != 0 {
+      try container.encodeIfPresent(testhashu32Fnv1, forKey: .testhashu32Fnv1)
+    }
+    if testhashs64Fnv1 != 0 {
+      try container.encodeIfPresent(testhashs64Fnv1, forKey: .testhashs64Fnv1)
+    }
+    if testhashu64Fnv1 != 0 {
+      try container.encodeIfPresent(testhashu64Fnv1, forKey: .testhashu64Fnv1)
+    }
+    if testhashs32Fnv1a != 0 {
+      try container.encodeIfPresent(testhashs32Fnv1a, forKey: .testhashs32Fnv1a)
+    }
+    if testhashu32Fnv1a != 0 {
+      try container.encodeIfPresent(testhashu32Fnv1a, forKey: .testhashu32Fnv1a)
+    }
+    if testhashs64Fnv1a != 0 {
+      try container.encodeIfPresent(testhashs64Fnv1a, forKey: .testhashs64Fnv1a)
+    }
+    if testhashu64Fnv1a != 0 {
+      try container.encodeIfPresent(testhashu64Fnv1a, forKey: .testhashu64Fnv1a)
+    }
+    if testarrayofboolsCount > 0 {
+      try container.encodeIfPresent(testarrayofbools, forKey: .testarrayofbools)
+    }
+    if testf != 3.14159 {
+      try container.encodeIfPresent(testf, forKey: .testf)
+    }
+    if testf2 != 3.0 {
+      try container.encodeIfPresent(testf2, forKey: .testf2)
+    }
+    if testf3 != 0.0 {
+      try container.encodeIfPresent(testf3, forKey: .testf3)
+    }
+    if testarrayofstring2Count > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .testarrayofstring2)
+      for index in 0..<testarrayofstring2Count {
+        guard let type = testarrayofstring2(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if testarrayofsortedstructCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .testarrayofsortedstruct)
+      for index in 0..<testarrayofsortedstructCount {
+        guard let type = testarrayofsortedstruct(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if flexCount > 0 {
+      try container.encodeIfPresent(flex, forKey: .flex)
+    }
+    if test5Count > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .test5)
+      for index in 0..<test5Count {
+        guard let type = test5(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if vectorOfLongsCount > 0 {
+      try container.encodeIfPresent(vectorOfLongs, forKey: .vectorOfLongs)
+    }
+    if vectorOfDoublesCount > 0 {
+      try container.encodeIfPresent(vectorOfDoubles, forKey: .vectorOfDoubles)
+    }
+    try container.encodeIfPresent(parentNamespaceTest, forKey: .parentNamespaceTest)
+    if vectorOfReferrablesCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .vectorOfReferrables)
+      for index in 0..<vectorOfReferrablesCount {
+        guard let type = vectorOfReferrables(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if singleWeakReference != 0 {
+      try container.encodeIfPresent(singleWeakReference, forKey: .singleWeakReference)
+    }
+    if vectorOfWeakReferencesCount > 0 {
+      try container.encodeIfPresent(vectorOfWeakReferences, forKey: .vectorOfWeakReferences)
+    }
+    if vectorOfStrongReferrablesCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .vectorOfStrongReferrables)
+      for index in 0..<vectorOfStrongReferrablesCount {
+        guard let type = vectorOfStrongReferrables(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if coOwningReference != 0 {
+      try container.encodeIfPresent(coOwningReference, forKey: .coOwningReference)
+    }
+    if vectorOfCoOwningReferencesCount > 0 {
+      try container.encodeIfPresent(vectorOfCoOwningReferences, forKey: .vectorOfCoOwningReferences)
+    }
+    if nonOwningReference != 0 {
+      try container.encodeIfPresent(nonOwningReference, forKey: .nonOwningReference)
+    }
+    if vectorOfNonOwningReferencesCount > 0 {
+      try container.encodeIfPresent(vectorOfNonOwningReferences, forKey: .vectorOfNonOwningReferences)
+    }
+    if anyUniqueType != .none_ {
+      try container.encodeIfPresent(anyUniqueType, forKey: .anyUniqueType)
+    }
+    switch anyUniqueType {
+    case .m:
+      let _v = anyUnique(type: MyGame_Example_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .anyUnique)
+    case .ts:
+      let _v = anyUnique(type: MyGame_Example_TestSimpleTableWithEnum.self)
+      try container.encodeIfPresent(_v, forKey: .anyUnique)
+    case .m2:
+      let _v = anyUnique(type: MyGame_Example2_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .anyUnique)
+    default: break;
+    }
+    if anyAmbiguousType != .none_ {
+      try container.encodeIfPresent(anyAmbiguousType, forKey: .anyAmbiguousType)
+    }
+    switch anyAmbiguousType {
+    case .m1:
+      let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
+    case .m2:
+      let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
+    case .m3:
+      let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
+      try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
+    default: break;
+    }
+    if vectorOfEnumsCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .vectorOfEnums)
+      for index in 0..<vectorOfEnumsCount {
+        guard let type = vectorOfEnums(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if signedEnum != .none_ {
+      try container.encodeIfPresent(signedEnum, forKey: .signedEnum)
+    }
+    if testrequirednestedflatbufferCount > 0 {
+      try container.encodeIfPresent(testrequirednestedflatbuffer, forKey: .testrequirednestedflatbuffer)
+    }
+    if scalarKeySortedTablesCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .scalarKeySortedTables)
+      for index in 0..<scalarKeySortedTablesCount {
+        guard let type = scalarKeySortedTables(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    try container.encodeIfPresent(nativeInline, forKey: .nativeInline)
+    if longEnumNonEnumDefault != .longone {
+      try container.encodeIfPresent(longEnumNonEnumDefault, forKey: .longEnumNonEnumDefault)
+    }
+    if longEnumNormalDefault != .longone {
+      try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
+    }
+  }
+}
+
+public class MyGame_Example_MonsterT: NativeObject {
+
+  public var pos: MyGame_Example_Vec3?
   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 test4: [MyGame_Example_Test?]
   public var testarrayofstring: [String?]
   public var testarrayoftables: [MyGame_Example_MonsterT?]
   public var enemy: MyGame_Example_MonsterT?
@@ -1080,9 +1973,9 @@
   public var testf2: Float32
   public var testf3: Float32
   public var testarrayofstring2: [String?]
-  public var testarrayofsortedstruct: [MyGame_Example_AbilityT?]
+  public var testarrayofsortedstruct: [MyGame_Example_Ability?]
   public var flex: [UInt8]
-  public var test5: [MyGame_Example_TestT?]
+  public var test5: [MyGame_Example_Test?]
   public var vectorOfLongs: [Int64]
   public var vectorOfDoubles: [Double]
   public var parentNamespaceTest: MyGame_InParentNamespaceT?
@@ -1099,10 +1992,13 @@
   public var vectorOfEnums: [MyGame_Example_Color]
   public var signedEnum: MyGame_Example_Race
   public var testrequirednestedflatbuffer: [UInt8]
+  public var scalarKeySortedTables: [MyGame_Example_StatT?]
+  public var nativeInline: MyGame_Example_Test?
+  public var longEnumNonEnumDefault: MyGame_Example_LongEnum
+  public var longEnumNormalDefault: MyGame_Example_LongEnum
 
   public init(_ _t: inout MyGame_Example_Monster) {
-    var __pos = _t.pos
-    pos = __pos?.unpack()
+    pos = _t.pos
     mana = _t.mana
     hp = _t.hp
     name = _t.name
@@ -1113,20 +2009,19 @@
     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)
+      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)
+      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)
+      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())
+        test4.append(_t.test4(at: index))
     }
     testarrayofstring = []
     for index in 0..<_t.testarrayofstringCount {
@@ -1167,8 +2062,7 @@
     }
     testarrayofsortedstruct = []
     for index in 0..<_t.testarrayofsortedstructCount {
-        var __v_ = _t.testarrayofsortedstruct(at: index)
-        testarrayofsortedstruct.append(__v_?.unpack())
+        testarrayofsortedstruct.append(_t.testarrayofsortedstruct(at: index))
     }
     flex = []
     for index in 0..<_t.flexCount {
@@ -1176,8 +2070,7 @@
     }
     test5 = []
     for index in 0..<_t.test5Count {
-        var __v_ = _t.test5(at: index)
-        test5.append(__v_?.unpack())
+        test5.append(_t.test5(at: index))
     }
     vectorOfLongs = []
     for index in 0..<_t.vectorOfLongsCount {
@@ -1216,26 +2109,26 @@
     }
     switch _t.anyUniqueType {
     case .m:
-        var _v = _t.anyUnique(type: MyGame_Example_Monster.self)
-        anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .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)
+      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)
+      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)
+      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)
+      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)
+      var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
+      anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m3)
     default: break
     }
     vectorOfEnums = []
@@ -1247,10 +2140,18 @@
     for index in 0..<_t.testrequirednestedflatbufferCount {
         testrequirednestedflatbuffer.append(_t.testrequirednestedflatbuffer(at: index))
     }
+    scalarKeySortedTables = []
+    for index in 0..<_t.scalarKeySortedTablesCount {
+        var __v_ = _t.scalarKeySortedTables(at: index)
+        scalarKeySortedTables.append(__v_?.unpack())
+    }
+    nativeInline = _t.nativeInline
+    longEnumNonEnumDefault = _t.longEnumNonEnumDefault
+    longEnumNormalDefault = _t.longEnumNormalDefault
   }
 
   public init() {
-    pos = MyGame_Example_Vec3T()
+    pos = MyGame_Example_Vec3()
     mana = 150
     hp = 100
     name = ""
@@ -1293,18 +2194,22 @@
     vectorOfEnums = []
     signedEnum = .none_
     testrequirednestedflatbuffer = []
+    scalarKeySortedTables = []
+    nativeInline = MyGame_Example_Test()
+    longEnumNonEnumDefault = .longone
+    longEnumNormalDefault = .longone
   }
 
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
 
 }
-public struct MyGame_Example_TypeAliases: FlatBufferObject, ObjectAPI {
+public struct MyGame_Example_TypeAliases: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -1366,9 +2271,9 @@
   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 addVectorOf(v8: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: v8, at: VTOFFSET.v8.p) }
+  public static func addVectorOf(vf64: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vf64, at: VTOFFSET.vf64.p) }
+  public static func endTypeAliases(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createTypeAliases(
     _ fbb: inout FlatBufferBuilder,
     i8: Int8 = 0,
@@ -1381,9 +2286,9 @@
     u64: UInt64 = 0,
     f32: Float32 = 0.0,
     f64: Double = 0.0,
-    vectorOfV8 v8: Offset<UOffset> = Offset(),
-    vectorOfVf64 vf64: Offset<UOffset> = Offset()
-  ) -> Offset<UOffset> {
+    v8VectorOffset v8: Offset = Offset(),
+    vf64VectorOffset vf64: Offset = Offset()
+  ) -> Offset {
     let __start = MyGame_Example_TypeAliases.startTypeAliases(&fbb)
     MyGame_Example_TypeAliases.add(i8: i8, &fbb)
     MyGame_Example_TypeAliases.add(u8: u8, &fbb)
@@ -1404,12 +2309,12 @@
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT) -> Offset {
     let __v8 = builder.createVector(obj.v8)
     let __vf64 = builder.createVector(obj.vf64)
     let __root = MyGame_Example_TypeAliases.startTypeAliases(&builder)
@@ -1427,9 +2332,83 @@
     MyGame_Example_TypeAliases.addVectorOf(vf64: __vf64, &builder)
     return MyGame_Example_TypeAliases.endTypeAliases(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.i8.p, fieldName: "i8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.u8.p, fieldName: "u8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.i16.p, fieldName: "i16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.u16.p, fieldName: "u16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.i32.p, fieldName: "i32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.u32.p, fieldName: "u32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.i64.p, fieldName: "i64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.u64.p, fieldName: "u64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.f32.p, fieldName: "f32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.f64.p, fieldName: "f64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.v8.p, fieldName: "v8", required: false, type: ForwardOffset<Vector<Int8, Int8>>.self)
+    try _v.visit(field: VTOFFSET.vf64.p, fieldName: "vf64", required: false, type: ForwardOffset<Vector<Double, Double>>.self)
+    _v.finish()
+  }
 }
 
-public class MyGame_Example_TypeAliasesT: NativeTable {
+extension MyGame_Example_TypeAliases: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case i8 = "i8"
+    case u8 = "u8"
+    case i16 = "i16"
+    case u16 = "u16"
+    case i32 = "i32"
+    case u32 = "u32"
+    case i64 = "i64"
+    case u64 = "u64"
+    case f32 = "f32"
+    case f64 = "f64"
+    case v8 = "v8"
+    case vf64 = "vf64"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if i8 != 0 {
+      try container.encodeIfPresent(i8, forKey: .i8)
+    }
+    if u8 != 0 {
+      try container.encodeIfPresent(u8, forKey: .u8)
+    }
+    if i16 != 0 {
+      try container.encodeIfPresent(i16, forKey: .i16)
+    }
+    if u16 != 0 {
+      try container.encodeIfPresent(u16, forKey: .u16)
+    }
+    if i32 != 0 {
+      try container.encodeIfPresent(i32, forKey: .i32)
+    }
+    if u32 != 0 {
+      try container.encodeIfPresent(u32, forKey: .u32)
+    }
+    if i64 != 0 {
+      try container.encodeIfPresent(i64, forKey: .i64)
+    }
+    if u64 != 0 {
+      try container.encodeIfPresent(u64, forKey: .u64)
+    }
+    if f32 != 0.0 {
+      try container.encodeIfPresent(f32, forKey: .f32)
+    }
+    if f64 != 0.0 {
+      try container.encodeIfPresent(f64, forKey: .f64)
+    }
+    if v8Count > 0 {
+      try container.encodeIfPresent(v8, forKey: .v8)
+    }
+    if vf64Count > 0 {
+      try container.encodeIfPresent(vf64, forKey: .vf64)
+    }
+  }
+}
+
+public class MyGame_Example_TypeAliasesT: NativeObject {
 
   public var i8: Int8
   public var u8: UInt8
diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift
new file mode 100644
index 0000000..3ebaa2a
--- /dev/null
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift
@@ -0,0 +1,218 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public enum ABC: Int32, Enum, Verifiable {
+  public typealias T = Int32
+  public static var byteSize: Int { return MemoryLayout<Int32>.size }
+  public var value: Int32 { return self.rawValue }
+  case a = 0
+  case b = 1
+  case c = 2
+
+  public static var max: ABC { return .c }
+  public static var min: ABC { return .a }
+}
+
+extension ABC: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .a: try container.encode("A")
+    case .b: try container.encode("B")
+    case .c: try container.encode("C")
+    }
+  }
+}
+
+public struct MoreDefaults: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static func getRootAsMoreDefaults(bb: ByteBuffer) -> MoreDefaults { return MoreDefaults(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 ints = 4
+    case floats = 6
+    case emptyString = 8
+    case someString = 10
+    case abcs = 12
+    case bools = 14
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var intsCount: Int32 { let o = _accessor.offset(VTOFFSET.ints.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func ints(at index: Int32) -> Int32 { let o = _accessor.offset(VTOFFSET.ints.v); return o == 0 ? 0 : _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4) }
+  public var ints: [Int32] { return _accessor.getVector(at: VTOFFSET.ints.v) ?? [] }
+  public var floatsCount: Int32 { let o = _accessor.offset(VTOFFSET.floats.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func floats(at index: Int32) -> Float32 { let o = _accessor.offset(VTOFFSET.floats.v); return o == 0 ? 0 : _accessor.directRead(of: Float32.self, offset: _accessor.vector(at: o) + index * 4) }
+  public var floats: [Float32] { return _accessor.getVector(at: VTOFFSET.floats.v) ?? [] }
+  public var emptyString: String? { let o = _accessor.offset(VTOFFSET.emptyString.v); return o == 0 ? "" : _accessor.string(at: o) }
+  public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.emptyString.v) }
+  public var someString: String? { let o = _accessor.offset(VTOFFSET.someString.v); return o == 0 ? "some" : _accessor.string(at: o) }
+  public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.someString.v) }
+  public var abcsCount: Int32 { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func abcs(at index: Int32) -> ABC? { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? ABC.a : ABC(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) }
+  public var boolsCount: Int32 { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func bools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? true : _accessor.directRead(of: Bool.self, offset: _accessor.vector(at: o) + index * 1) }
+  public var bools: [Bool] { return _accessor.getVector(at: VTOFFSET.bools.v) ?? [] }
+  public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) }
+  public static func addVectorOf(ints: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VTOFFSET.ints.p) }
+  public static func addVectorOf(floats: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VTOFFSET.floats.p) }
+  public static func add(emptyString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VTOFFSET.emptyString.p) }
+  public static func add(someString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VTOFFSET.someString.p) }
+  public static func addVectorOf(abcs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VTOFFSET.abcs.p) }
+  public static func addVectorOf(bools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VTOFFSET.bools.p) }
+  public static func endMoreDefaults(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createMoreDefaults(
+    _ fbb: inout FlatBufferBuilder,
+    intsVectorOffset ints: Offset = Offset(),
+    floatsVectorOffset floats: Offset = Offset(),
+    emptyStringOffset emptyString: Offset = Offset(),
+    someStringOffset someString: Offset = Offset(),
+    abcsVectorOffset abcs: Offset = Offset(),
+    boolsVectorOffset bools: Offset = Offset()
+  ) -> Offset {
+    let __start = MoreDefaults.startMoreDefaults(&fbb)
+    MoreDefaults.addVectorOf(ints: ints, &fbb)
+    MoreDefaults.addVectorOf(floats: floats, &fbb)
+    MoreDefaults.add(emptyString: emptyString, &fbb)
+    MoreDefaults.add(someString: someString, &fbb)
+    MoreDefaults.addVectorOf(abcs: abcs, &fbb)
+    MoreDefaults.addVectorOf(bools: bools, &fbb)
+    return MoreDefaults.endMoreDefaults(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> MoreDefaultsT {
+    return MoreDefaultsT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MoreDefaultsT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MoreDefaultsT) -> Offset {
+    let __ints = builder.createVector(obj.ints)
+    let __floats = builder.createVector(obj.floats)
+    let __emptyString: Offset
+    if let s = obj.emptyString {
+      __emptyString = builder.create(string: s)
+    } else {
+      __emptyString = Offset()
+    }
+
+    let __someString: Offset
+    if let s = obj.someString {
+      __someString = builder.create(string: s)
+    } else {
+      __someString = Offset()
+    }
+
+    let __abcs = builder.createVector(obj.abcs)
+    let __bools = builder.createVector(obj.bools)
+    let __root = MoreDefaults.startMoreDefaults(&builder)
+    MoreDefaults.addVectorOf(ints: __ints, &builder)
+    MoreDefaults.addVectorOf(floats: __floats, &builder)
+    MoreDefaults.add(emptyString: __emptyString, &builder)
+    MoreDefaults.add(someString: __someString, &builder)
+    MoreDefaults.addVectorOf(abcs: __abcs, &builder)
+    MoreDefaults.addVectorOf(bools: __bools, &builder)
+    return MoreDefaults.endMoreDefaults(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.ints.p, fieldName: "ints", required: false, type: ForwardOffset<Vector<Int32, Int32>>.self)
+    try _v.visit(field: VTOFFSET.floats.p, fieldName: "floats", required: false, type: ForwardOffset<Vector<Float32, Float32>>.self)
+    try _v.visit(field: VTOFFSET.emptyString.p, fieldName: "emptyString", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.someString.p, fieldName: "someString", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.abcs.p, fieldName: "abcs", required: false, type: ForwardOffset<Vector<ABC, ABC>>.self)
+    try _v.visit(field: VTOFFSET.bools.p, fieldName: "bools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
+    _v.finish()
+  }
+}
+
+extension MoreDefaults: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case ints = "ints"
+    case floats = "floats"
+    case emptyString = "empty_string"
+    case someString = "some_string"
+    case abcs = "abcs"
+    case bools = "bools"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if intsCount > 0 {
+      try container.encodeIfPresent(ints, forKey: .ints)
+    }
+    if floatsCount > 0 {
+      try container.encodeIfPresent(floats, forKey: .floats)
+    }
+    try container.encodeIfPresent(emptyString, forKey: .emptyString)
+    try container.encodeIfPresent(someString, forKey: .someString)
+    if abcsCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .abcs)
+      for index in 0..<abcsCount {
+        guard let type = abcs(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if boolsCount > 0 {
+      try container.encodeIfPresent(bools, forKey: .bools)
+    }
+  }
+}
+
+public class MoreDefaultsT: NativeObject {
+
+  public var ints: [Int32]
+  public var floats: [Float32]
+  public var emptyString: String?
+  public var someString: String?
+  public var abcs: [ABC]
+  public var bools: [Bool]
+
+  public init(_ _t: inout MoreDefaults) {
+    ints = []
+    for index in 0..<_t.intsCount {
+        ints.append(_t.ints(at: index))
+    }
+    floats = []
+    for index in 0..<_t.floatsCount {
+        floats.append(_t.floats(at: index))
+    }
+    emptyString = _t.emptyString
+    someString = _t.someString
+    abcs = []
+    for index in 0..<_t.abcsCount {
+        abcs.append(_t.abcs(at: index)!)
+    }
+    bools = []
+    for index in 0..<_t.boolsCount {
+        bools.append(_t.bools(at: index))
+    }
+  }
+
+  public init() {
+    ints = []
+    floats = []
+    emptyString = ""
+    someString = "some"
+    abcs = []
+    bools = []
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: MoreDefaults.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
index 697edde..0f427c8 100644
--- 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
@@ -4,26 +4,36 @@
 
 import FlatBuffers
 
-public enum optional_scalars_OptionalByte: Int8, Enum { 
+public enum optional_scalars_OptionalByte: Int8, Enum, Verifiable {
   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 {
+extension optional_scalars_OptionalByte: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("None")
+    case .one: try container.encode("One")
+    case .two: try container.encode("Two")
+    }
+  }
+}
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+public struct optional_scalars_ScalarStuff: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -101,7 +111,7 @@
   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 maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? nil : 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 }
@@ -145,7 +155,7 @@
   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 endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createScalarStuff(
     _ fbb: inout FlatBufferBuilder,
     justI8: Int8 = 0,
@@ -184,7 +194,7 @@
     justEnum: optional_scalars_OptionalByte = .none_,
     maybeEnum: optional_scalars_OptionalByte? = nil,
     defaultEnum: optional_scalars_OptionalByte = .one
-  ) -> Offset<UOffset> {
+  ) -> Offset {
     let __start = optional_scalars_ScalarStuff.startScalarStuff(&fbb)
     optional_scalars_ScalarStuff.add(justI8: justI8, &fbb)
     optional_scalars_ScalarStuff.add(maybeI8: maybeI8, &fbb)
@@ -224,5 +234,175 @@
     optional_scalars_ScalarStuff.add(defaultEnum: defaultEnum, &fbb)
     return optional_scalars_ScalarStuff.endScalarStuff(&fbb, start: __start)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.justI8.p, fieldName: "justI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.maybeI8.p, fieldName: "maybeI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.defaultI8.p, fieldName: "defaultI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.justU8.p, fieldName: "justU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.maybeU8.p, fieldName: "maybeU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.defaultU8.p, fieldName: "defaultU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.justI16.p, fieldName: "justI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.maybeI16.p, fieldName: "maybeI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.defaultI16.p, fieldName: "defaultI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.justU16.p, fieldName: "justU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.maybeU16.p, fieldName: "maybeU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.defaultU16.p, fieldName: "defaultU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.justI32.p, fieldName: "justI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.maybeI32.p, fieldName: "maybeI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.defaultI32.p, fieldName: "defaultI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.justU32.p, fieldName: "justU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.maybeU32.p, fieldName: "maybeU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.defaultU32.p, fieldName: "defaultU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.justI64.p, fieldName: "justI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.maybeI64.p, fieldName: "maybeI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.defaultI64.p, fieldName: "defaultI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.justU64.p, fieldName: "justU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.maybeU64.p, fieldName: "maybeU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.defaultU64.p, fieldName: "defaultU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.justF32.p, fieldName: "justF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.maybeF32.p, fieldName: "maybeF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.defaultF32.p, fieldName: "defaultF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.justF64.p, fieldName: "justF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.maybeF64.p, fieldName: "maybeF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultF64.p, fieldName: "defaultF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.justBool.p, fieldName: "justBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.maybeBool.p, fieldName: "maybeBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.defaultBool.p, fieldName: "defaultBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.justEnum.p, fieldName: "justEnum", required: false, type: optional_scalars_OptionalByte.self)
+    try _v.visit(field: VTOFFSET.maybeEnum.p, fieldName: "maybeEnum", required: false, type: optional_scalars_OptionalByte.self)
+    try _v.visit(field: VTOFFSET.defaultEnum.p, fieldName: "defaultEnum", required: false, type: optional_scalars_OptionalByte.self)
+    _v.finish()
+  }
+}
+
+extension optional_scalars_ScalarStuff: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case justI8 = "just_i8"
+    case maybeI8 = "maybe_i8"
+    case defaultI8 = "default_i8"
+    case justU8 = "just_u8"
+    case maybeU8 = "maybe_u8"
+    case defaultU8 = "default_u8"
+    case justI16 = "just_i16"
+    case maybeI16 = "maybe_i16"
+    case defaultI16 = "default_i16"
+    case justU16 = "just_u16"
+    case maybeU16 = "maybe_u16"
+    case defaultU16 = "default_u16"
+    case justI32 = "just_i32"
+    case maybeI32 = "maybe_i32"
+    case defaultI32 = "default_i32"
+    case justU32 = "just_u32"
+    case maybeU32 = "maybe_u32"
+    case defaultU32 = "default_u32"
+    case justI64 = "just_i64"
+    case maybeI64 = "maybe_i64"
+    case defaultI64 = "default_i64"
+    case justU64 = "just_u64"
+    case maybeU64 = "maybe_u64"
+    case defaultU64 = "default_u64"
+    case justF32 = "just_f32"
+    case maybeF32 = "maybe_f32"
+    case defaultF32 = "default_f32"
+    case justF64 = "just_f64"
+    case maybeF64 = "maybe_f64"
+    case defaultF64 = "default_f64"
+    case justBool = "just_bool"
+    case maybeBool = "maybe_bool"
+    case defaultBool = "default_bool"
+    case justEnum = "just_enum"
+    case maybeEnum = "maybe_enum"
+    case defaultEnum = "default_enum"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if justI8 != 0 {
+      try container.encodeIfPresent(justI8, forKey: .justI8)
+    }
+    try container.encodeIfPresent(maybeI8, forKey: .maybeI8)
+    if defaultI8 != 42 {
+      try container.encodeIfPresent(defaultI8, forKey: .defaultI8)
+    }
+    if justU8 != 0 {
+      try container.encodeIfPresent(justU8, forKey: .justU8)
+    }
+    try container.encodeIfPresent(maybeU8, forKey: .maybeU8)
+    if defaultU8 != 42 {
+      try container.encodeIfPresent(defaultU8, forKey: .defaultU8)
+    }
+    if justI16 != 0 {
+      try container.encodeIfPresent(justI16, forKey: .justI16)
+    }
+    try container.encodeIfPresent(maybeI16, forKey: .maybeI16)
+    if defaultI16 != 42 {
+      try container.encodeIfPresent(defaultI16, forKey: .defaultI16)
+    }
+    if justU16 != 0 {
+      try container.encodeIfPresent(justU16, forKey: .justU16)
+    }
+    try container.encodeIfPresent(maybeU16, forKey: .maybeU16)
+    if defaultU16 != 42 {
+      try container.encodeIfPresent(defaultU16, forKey: .defaultU16)
+    }
+    if justI32 != 0 {
+      try container.encodeIfPresent(justI32, forKey: .justI32)
+    }
+    try container.encodeIfPresent(maybeI32, forKey: .maybeI32)
+    if defaultI32 != 42 {
+      try container.encodeIfPresent(defaultI32, forKey: .defaultI32)
+    }
+    if justU32 != 0 {
+      try container.encodeIfPresent(justU32, forKey: .justU32)
+    }
+    try container.encodeIfPresent(maybeU32, forKey: .maybeU32)
+    if defaultU32 != 42 {
+      try container.encodeIfPresent(defaultU32, forKey: .defaultU32)
+    }
+    if justI64 != 0 {
+      try container.encodeIfPresent(justI64, forKey: .justI64)
+    }
+    try container.encodeIfPresent(maybeI64, forKey: .maybeI64)
+    if defaultI64 != 42 {
+      try container.encodeIfPresent(defaultI64, forKey: .defaultI64)
+    }
+    if justU64 != 0 {
+      try container.encodeIfPresent(justU64, forKey: .justU64)
+    }
+    try container.encodeIfPresent(maybeU64, forKey: .maybeU64)
+    if defaultU64 != 42 {
+      try container.encodeIfPresent(defaultU64, forKey: .defaultU64)
+    }
+    if justF32 != 0.0 {
+      try container.encodeIfPresent(justF32, forKey: .justF32)
+    }
+    try container.encodeIfPresent(maybeF32, forKey: .maybeF32)
+    if defaultF32 != 42.0 {
+      try container.encodeIfPresent(defaultF32, forKey: .defaultF32)
+    }
+    if justF64 != 0.0 {
+      try container.encodeIfPresent(justF64, forKey: .justF64)
+    }
+    try container.encodeIfPresent(maybeF64, forKey: .maybeF64)
+    if defaultF64 != 42.0 {
+      try container.encodeIfPresent(defaultF64, forKey: .defaultF64)
+    }
+    if justBool != false {
+      try container.encodeIfPresent(justBool, forKey: .justBool)
+    }
+    try container.encodeIfPresent(maybeBool, forKey: .maybeBool)
+    if defaultBool != true {
+      try container.encodeIfPresent(defaultBool, forKey: .defaultBool)
+    }
+    if justEnum != .none_ {
+      try container.encodeIfPresent(justEnum, forKey: .justEnum)
+    }
+    try container.encodeIfPresent(maybeEnum, forKey: .maybeEnum)
+    if defaultEnum != .one {
+      try container.encodeIfPresent(defaultEnum, forKey: .defaultEnum)
+    }
+  }
 }
 
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
index 88cb4fb..59ed005 100644
--- 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
@@ -4,8 +4,13 @@
 
 import FlatBuffers
 
-public enum Character: UInt8, Enum { 
+public enum Character: UInt8, UnionEnum {
   public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }
   case none_ = 0
@@ -15,144 +20,315 @@
   case bookfan = 4
   case other = 5
   case unused = 6
-  
 
   public static var max: Character { return .unused }
   public static var min: Character { return .none_ }
 }
 
+extension Character: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .mulan: try container.encode("MuLan")
+    case .rapunzel: try container.encode("Rapunzel")
+    case .belle: try container.encode("Belle")
+    case .bookfan: try container.encode("BookFan")
+    case .other: try container.encode("Other")
+    case .unused: try container.encode("Unused")
+    }
+  }
+}
+
 public struct CharacterUnion {
   public var type: Character
-  public var value: NativeTable?
-  public init(_ v: NativeTable?, type: Character) {
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: Character) {
     self.type = type
     self.value = v
   }
-  public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
     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)
+      var __obj = value as? Rapunzel
+      return Rapunzel_Mutable.pack(&builder, obj: &__obj)
     case .belle:
-      var __obj = value as? BookReaderT
-      return BookReader.pack(&builder, obj: &__obj)
+      var __obj = value as? BookReader
+      return BookReader_Mutable.pack(&builder, obj: &__obj)
     case .bookfan:
-      var __obj = value as? BookReaderT
-      return BookReader.pack(&builder, obj: &__obj)
+      var __obj = value as? BookReader
+      return BookReader_Mutable.pack(&builder, obj: &__obj)
+    case .other:
+      var __obj = value as? String
+      return String.pack(&builder, obj: &__obj)
+    case .unused:
+      var __obj = value as? String
+      return String.pack(&builder, obj: &__obj)
     default: return Offset()
     }
   }
 }
-public struct Rapunzel: Readable {
+public enum Gadget: UInt8, UnionEnum {
+  public typealias T = UInt8
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
+  public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+  public var value: UInt8 { return self.rawValue }
+  case none_ = 0
+  case fallingtub = 1
+  case handfan = 2
+
+  public static var max: Gadget { return .handfan }
+  public static var min: Gadget { return .none_ }
+}
+
+extension Gadget: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .fallingtub: try container.encode("FallingTub")
+    case .handfan: try container.encode("HandFan")
+    }
+  }
+}
+
+public struct GadgetUnion {
+  public var type: Gadget
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: Gadget) {
+    self.type = type
+    self.value = v
+  }
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
+    switch type {
+    case .fallingtub:
+      var __obj = value as? FallingTub
+      return FallingTub_Mutable.pack(&builder, obj: &__obj)
+    case .handfan:
+      var __obj = value as? HandFanT
+      return HandFan.pack(&builder, obj: &__obj)
+    default: return Offset()
+    }
+  }
+}
+public struct Rapunzel: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+
+  private var _hairLength: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _hairLength = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(hairLength: Int32) {
+    _hairLength = hairLength
+  }
+
+  public init() {
+    _hairLength = 0
+  }
+
+  public init(_ _t: inout Rapunzel_Mutable) {
+    _hairLength = _t.hairLength
+  }
+
+  public var hairLength: Int32 { _hairLength }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: Rapunzel.self)
+  }
+}
+
+extension Rapunzel: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case hairLength = "hair_length"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if hairLength != 0 {
+      try container.encodeIfPresent(hairLength, forKey: .hairLength)
+    }
+  }
+}
+
+public struct Rapunzel_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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 mutating func unpack() -> Rapunzel {
+    return Rapunzel(&self)
   }
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout RapunzelT?) -> Offset<UOffset> {
-    guard var obj = obj else { return Offset<UOffset>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel?) -> Offset {
+    guard var obj = obj else { return Offset() }
     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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel) -> Offset {
+    return builder.create(struct: obj)
   }
 }
 
-public class RapunzelT: NativeTable {
+public struct BookReader: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  public var hairLength: Int32
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-  public init(_ _t: inout Rapunzel) {
-    hairLength = _t.hairLength
+  private var _booksRead: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _booksRead = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(booksRead: Int32) {
+    _booksRead = booksRead
   }
 
   public init() {
-    hairLength = 0
+    _booksRead = 0
   }
 
-}
-public struct BookReader: Readable {
+  public init(_ _t: inout BookReader_Mutable) {
+    _booksRead = _t.booksRead
+  }
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  public var booksRead: Int32 { _booksRead }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: BookReader.self)
+  }
+}
+
+extension BookReader: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case booksRead = "books_read"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if booksRead != 0 {
+      try container.encodeIfPresent(booksRead, forKey: .booksRead)
+    }
+  }
+}
+
+public struct BookReader_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_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 mutating func unpack() -> BookReader {
+    return BookReader(&self)
   }
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReaderT?) -> Offset<UOffset> {
-    guard var obj = obj else { return Offset<UOffset>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader?) -> Offset {
+    guard var obj = obj else { return Offset() }
     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 static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader) -> Offset {
+    return builder.create(struct: obj)
   }
 }
 
-public class BookReaderT: NativeTable {
+public struct FallingTub: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
 
-  public var booksRead: Int32
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
 
-  public init(_ _t: inout BookReader) {
-    booksRead = _t.booksRead
+  private var _weight: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _weight = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(weight: Int32) {
+    _weight = weight
   }
 
   public init() {
-    booksRead = 0
+    _weight = 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()
+  public init(_ _t: inout FallingTub_Mutable) {
+    _weight = _t.weight
   }
 
+  public var weight: Int32 { _weight }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: FallingTub.self)
+  }
 }
 
-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()
+extension FallingTub: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case weight = "weight"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if weight != 0 {
+      try container.encodeIfPresent(weight, forKey: .weight)
+    }
+  }
+}
+
+public struct FallingTub_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var weight: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+  @discardableResult public func mutate(weight: Int32) -> Bool { return _accessor.mutate(weight, index: 0) }
+  
+
+  public mutating func unpack() -> FallingTub {
+    return FallingTub(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout FallingTub?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
   }
 
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout FallingTub) -> Offset {
+    return builder.create(struct: obj)
+  }
 }
 
-public struct Attacker: FlatBufferObject, ObjectAPI {
+public struct Attacker: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -168,11 +344,11 @@
   @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 endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createAttacker(
     _ fbb: inout FlatBufferBuilder,
     swordAttackDamage: Int32 = 0
-  ) -> Offset<UOffset> {
+  ) -> Offset {
     let __start = Attacker.startAttacker(&fbb)
     Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
     return Attacker.endAttacker(&fbb, start: __start)
@@ -182,19 +358,38 @@
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT) -> Offset {
     let __root = Attacker.startAttacker(&builder)
     Attacker.add(swordAttackDamage: obj.swordAttackDamage, &builder)
     return Attacker.endAttacker(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.swordAttackDamage.p, fieldName: "swordAttackDamage", required: false, type: Int32.self)
+    _v.finish()
+  }
 }
 
-public class AttackerT: NativeTable {
+extension Attacker: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case swordAttackDamage = "sword_attack_damage"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if swordAttackDamage != 0 {
+      try container.encodeIfPresent(swordAttackDamage, forKey: .swordAttackDamage)
+    }
+  }
+}
+
+public class AttackerT: NativeObject {
 
   public var swordAttackDamage: Int32
 
@@ -209,13 +404,95 @@
   public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
 
 }
-public struct Movie: FlatBufferObject, ObjectAPI {
+public struct HandFan: FlatBufferObject, Verifiable, ObjectAPIPacker {
 
-  static func validateVersion() { FlatBuffersVersion_1_12_0() }
+  static func validateVersion() { FlatBuffersVersion_2_0_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 finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
+  public static func getRootAsHandFan(bb: ByteBuffer) -> HandFan { return HandFan(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 length = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var length: Int32 { let o = _accessor.offset(VTOFFSET.length.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+  @discardableResult public func mutate(length: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.length.v);  return _accessor.mutate(length, index: o) }
+  public static func startHandFan(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(length: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: length, def: 0, at: VTOFFSET.length.p) }
+  public static func endHandFan(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHandFan(
+    _ fbb: inout FlatBufferBuilder,
+    length: Int32 = 0
+  ) -> Offset {
+    let __start = HandFan.startHandFan(&fbb)
+    HandFan.add(length: length, &fbb)
+    return HandFan.endHandFan(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> HandFanT {
+    return HandFanT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout HandFanT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout HandFanT) -> Offset {
+    let __root = HandFan.startHandFan(&builder)
+    HandFan.add(length: obj.length, &builder)
+    return HandFan.endHandFan(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.length.p, fieldName: "length", required: false, type: Int32.self)
+    _v.finish()
+  }
+}
+
+extension HandFan: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case length = "length"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if length != 0 {
+      try container.encodeIfPresent(length, forKey: .length)
+    }
+  }
+}
+
+public class HandFanT: NativeObject {
+
+  public var length: Int32
+
+  public init(_ _t: inout HandFan) {
+    length = _t.length
+  }
+
+  public init() {
+    length = 0
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: HandFan.self) }
+
+}
+public struct Movie: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_2_0_0() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, 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 }
@@ -231,24 +508,24 @@
   }
 
   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 func mainCharacter<T: FlatbuffersInitializable>(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 func characters<T: FlatbuffersInitializable>(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 add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
+  public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
+  public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
+  public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(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> {
+    mainCharacterOffset mainCharacter: Offset = Offset(),
+    charactersTypeVectorOffset charactersType: Offset = Offset(),
+    charactersVectorOffset characters: Offset = Offset()
+  ) -> Offset {
     let __start = Movie.startMovie(&fbb)
     Movie.add(mainCharacterType: mainCharacterType, &fbb)
     Movie.add(mainCharacter: mainCharacter, &fbb)
@@ -261,14 +538,14 @@
   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>() }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT?) -> Offset {
+    guard var obj = obj else { return Offset() }
     return pack(&builder, obj: &obj)
   }
 
-  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT) -> Offset<UOffset> {
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT) -> Offset {
     let __mainCharacter = obj.mainCharacter?.pack(builder: &builder) ?? Offset()
-    var __characters__: [Offset<UOffset>] = []
+    var __characters__: [Offset] = []
     for i in obj.characters {
       guard let off = i?.pack(builder: &builder) else { continue }
       __characters__.append(off)
@@ -285,9 +562,116 @@
     Movie.addVectorOf(characters: __characters, &builder)
     return Movie.endMovie(&builder, start: __root)
   }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(unionKey: VTOFFSET.mainCharacterType.p, unionField: VTOFFSET.mainCharacter.p, unionKeyName: "mainCharacterType", fieldName: "mainCharacter", required: false, completion: { (verifier, key: Character, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .mulan:
+        try ForwardOffset<Attacker>.verify(&verifier, at: pos, of: Attacker.self)
+      case .rapunzel:
+        try Rapunzel.verify(&verifier, at: pos, of: Rapunzel.self)
+      case .belle:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .bookfan:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .other:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      case .unused:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      }
+    })
+    try _v.visitUnionVector(unionKey: VTOFFSET.charactersType.p, unionField: VTOFFSET.characters.p, unionKeyName: "charactersType", fieldName: "characters", required: false, completion: { (verifier, key: Character, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .mulan:
+        try ForwardOffset<Attacker>.verify(&verifier, at: pos, of: Attacker.self)
+      case .rapunzel:
+        try Rapunzel.verify(&verifier, at: pos, of: Rapunzel.self)
+      case .belle:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .bookfan:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .other:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      case .unused:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      }
+    })
+    _v.finish()
+  }
 }
 
-public class MovieT: NativeTable {
+extension Movie: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case mainCharacterType = "main_character_type"
+    case mainCharacter = "main_character"
+    case charactersType = "characters_type"
+    case characters = "characters"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if mainCharacterType != .none_ {
+      try container.encodeIfPresent(mainCharacterType, forKey: .mainCharacterType)
+    }
+    switch mainCharacterType {
+    case .mulan:
+      let _v = mainCharacter(type: Attacker.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .rapunzel:
+      let _v = mainCharacter(type: Rapunzel.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .belle:
+      let _v = mainCharacter(type: BookReader.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .bookfan:
+      let _v = mainCharacter(type: BookReader.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .other:
+      let _v = mainCharacter(type: String.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .unused:
+      let _v = mainCharacter(type: String.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    default: break;
+    }
+    if charactersCount > 0 {
+      var enumsEncoder = container.nestedUnkeyedContainer(forKey: .charactersType)
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .characters)
+      for index in 0..<charactersCount {
+        guard let type = charactersType(at: index) else { continue }
+        try enumsEncoder.encode(type)
+        switch type {
+        case .mulan:
+          let _v = characters(at: index, type: Attacker.self)
+          try contentEncoder.encode(_v)
+        case .rapunzel:
+          let _v = characters(at: index, type: Rapunzel.self)
+          try contentEncoder.encode(_v)
+        case .belle:
+          let _v = characters(at: index, type: BookReader.self)
+          try contentEncoder.encode(_v)
+        case .bookfan:
+          let _v = characters(at: index, type: BookReader.self)
+          try contentEncoder.encode(_v)
+        case .other:
+          let _v = characters(at: index, type: String.self)
+          try contentEncoder.encode(_v)
+        case .unused:
+          let _v = characters(at: index, type: String.self)
+          try contentEncoder.encode(_v)
+        default: break;
+        }
+      }
+    }
+  }
+}
+
+public class MovieT: NativeObject {
 
   public var mainCharacter: CharacterUnion?
   public var characters: [CharacterUnion?]
@@ -295,34 +679,46 @@
   public init(_ _t: inout Movie) {
     switch _t.mainCharacterType {
     case .mulan:
-        var _v = _t.mainCharacter(type: Attacker.self)
-        mainCharacter = CharacterUnion(_v?.unpack(), type: .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)
+      var _v = _t.mainCharacter(type: Rapunzel_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .rapunzel)
     case .belle:
-        var _v = _t.mainCharacter(type: BookReader.self)
-        mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
+      var _v = _t.mainCharacter(type: BookReader_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
     case .bookfan:
-        var _v = _t.mainCharacter(type: BookReader.self)
-        mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
+      var _v = _t.mainCharacter(type: BookReader_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
+    case .other:
+      var _v = _t.mainCharacter(type: String.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .other)
+    case .unused:
+      var _v = _t.mainCharacter(type: String.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .unused)
     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))
+          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))
+          var _v = _t.characters(at: index, type: Rapunzel_Mutable.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))
+          var _v = _t.characters(at: index, type: BookReader_Mutable.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))
+          var _v = _t.characters(at: index, type: BookReader_Mutable.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .bookfan))
+        case .other:
+          var _v = _t.characters(at: index, type: String.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .other))
+        case .unused:
+          var _v = _t.characters(at: index, type: String.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .unused))
         default: break
         }
     }