text: # automatically generated by the FlatBuffers compiler, do not modify
  
  # namespace: NamespaceA
  
  import flatbuffers
  from flatbuffers.compat import import_numpy
  np = import_numpy()
  
  class TableInFirstNS(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = TableInFirstNS()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsTableInFirstNS(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      # TableInFirstNS
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # TableInFirstNS
      def FooTable(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              x = self._tab.Indirect(o + self._tab.Pos)
              obj = TableInNestedNS()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # TableInFirstNS
      def FooEnum(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
          return 0
  
      # TableInFirstNS
      def FooUnionType(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 0
  
      # TableInFirstNS
      def FooUnion(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
          if o != 0:
              from flatbuffers.table import Table
              obj = Table(bytearray(), 0)
              self._tab.Union(obj, o)
              return obj
          return None
  
      # TableInFirstNS
      def FooStruct(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
          if o != 0:
              x = o + self._tab.Pos
              obj = StructInNestedNS()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
  def Start(builder): builder.StartObject(5)
  def TableInFirstNSStart(builder):
      """This method is deprecated. Please switch to Start."""
      return Start(builder)
  def AddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0)
  def TableInFirstNSAddFooTable(builder, fooTable):
      """This method is deprecated. Please switch to AddFooTable."""
      return AddFooTable(builder, fooTable)
  def AddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0)
  def TableInFirstNSAddFooEnum(builder, fooEnum):
      """This method is deprecated. Please switch to AddFooEnum."""
      return AddFooEnum(builder, fooEnum)
  def AddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0)
  def TableInFirstNSAddFooUnionType(builder, fooUnionType):
      """This method is deprecated. Please switch to AddFooUnionType."""
      return AddFooUnionType(builder, fooUnionType)
  def AddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0)
  def TableInFirstNSAddFooUnion(builder, fooUnion):
      """This method is deprecated. Please switch to AddFooUnion."""
      return AddFooUnion(builder, fooUnion)
  def AddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0)
  def TableInFirstNSAddFooStruct(builder, fooStruct):
      """This method is deprecated. Please switch to AddFooStruct."""
      return AddFooStruct(builder, fooStruct)
  def End(builder): return builder.EndObject()
  def TableInFirstNSEnd(builder):
      """This method is deprecated. Please switch to End."""
      return End(builder)
  try:
      from typing import Optional, Union
  except:
      pass
  
  class TableInFirstNST(object):
  
      # TableInFirstNST
      def __init__(self):
          self.fooTable = None  # type: Optional[TableInNestedNST]
          self.fooEnum = 0  # type: int
          self.fooUnionType = 0  # type: int
          self.fooUnion = None  # type: Union[None, TableInNestedNST]
          self.fooStruct = None  # type: Optional[StructInNestedNST]
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          tableInFirstNS = TableInFirstNS()
          tableInFirstNS.Init(buf, pos)
          return cls.InitFromObj(tableInFirstNS)
  
      @classmethod
      def InitFromObj(cls, tableInFirstNS):
          x = TableInFirstNST()
          x._UnPack(tableInFirstNS)
          return x
  
      # TableInFirstNST
      def _UnPack(self, tableInFirstNS):
          if tableInFirstNS is None:
              return
          if tableInFirstNS.FooTable() is not None:
              self.fooTable = TableInNestedNST.InitFromObj(tableInFirstNS.FooTable())
          self.fooEnum = tableInFirstNS.FooEnum()
          self.fooUnionType = tableInFirstNS.FooUnionType()
          self.fooUnion = UnionInNestedNSCreator(self.fooUnionType, tableInFirstNS.FooUnion())
          if tableInFirstNS.FooStruct() is not None:
              self.fooStruct = StructInNestedNST.InitFromObj(tableInFirstNS.FooStruct())
  
      # TableInFirstNST
      def Pack(self, builder):
          if self.fooTable is not None:
              fooTable = self.fooTable.Pack(builder)
          if self.fooUnion is not None:
              fooUnion = self.fooUnion.Pack(builder)
          Start(builder)
          if self.fooTable is not None:
              AddFooTable(builder, fooTable)
          AddFooEnum(builder, self.fooEnum)
          AddFooUnionType(builder, self.fooUnionType)
          if self.fooUnion is not None:
              AddFooUnion(builder, fooUnion)
          if self.fooStruct is not None:
              fooStruct = self.fooStruct.Pack(builder)
              AddFooStruct(builder, fooStruct)
          tableInFirstNS = End(builder)
          return tableInFirstNS
  