"""
Autogenerated python message buffer code.
Source: clad/cloud/docs.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/cloud/docs.clad
"""

from __future__ import absolute_import
from __future__ import print_function

def _modify_path():
  import inspect, os, sys
  search_paths = [
    '../..',
    '../../../../victor-clad/tools/message-buffers/support/python',
  ]
  currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe())))
  for search_path in search_paths:
    search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path))))
    if search_path not in sys.path:
      sys.path.insert(0, search_path)
_modify_path()

import msgbuffers

Anki = msgbuffers.Namespace()
Anki.Vector = msgbuffers.Namespace()
Anki.Vector.JDocs = msgbuffers.Namespace()

from clad.cloud.common import Anki as _Anki
Anki.update(_Anki.deep_clone())

class Doc(object):
  "Generated message-passing structure."

  __slots__ = (
    '_docVersion', # uint_64
    '_fmtVersion', # uint_64
    '_metadata',   # string[uint_8]
    '_jsonDoc',    # string[uint_32]
  )

  @property
  def docVersion(self):
    "uint_64 docVersion struct property."
    return self._docVersion

  @docVersion.setter
  def docVersion(self, value):
    self._docVersion = msgbuffers.validate_integer(
      'Doc.docVersion', value, 0, 18446744073709551615)

  @property
  def fmtVersion(self):
    "uint_64 fmtVersion struct property."
    return self._fmtVersion

  @fmtVersion.setter
  def fmtVersion(self, value):
    self._fmtVersion = msgbuffers.validate_integer(
      'Doc.fmtVersion', value, 0, 18446744073709551615)

  @property
  def metadata(self):
    "string[uint_8] metadata struct property."
    return self._metadata

  @metadata.setter
  def metadata(self, value):
    self._metadata = msgbuffers.validate_string(
      'Doc.metadata', value, 255)

  @property
  def jsonDoc(self):
    "string[uint_32] jsonDoc struct property."
    return self._jsonDoc

  @jsonDoc.setter
  def jsonDoc(self, value):
    self._jsonDoc = msgbuffers.validate_string(
      'Doc.jsonDoc', value, 4294967295)

  def __init__(self, docVersion=0, fmtVersion=0, metadata='', jsonDoc=''):
    self.docVersion = docVersion
    self.fmtVersion = fmtVersion
    self.metadata = metadata
    self.jsonDoc = jsonDoc

  @classmethod
  def unpack(cls, buffer):
    "Reads a new Doc from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('Doc.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new Doc from the given BinaryReader."
    _docVersion = reader.read('Q')
    _fmtVersion = reader.read('Q')
    _metadata = reader.read_string('B')
    _jsonDoc = reader.read_string('I')
    return cls(_docVersion, _fmtVersion, _metadata, _jsonDoc)

  def pack(self):
    "Writes the current Doc, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current Doc to the given BinaryWriter."
    writer.write(self._docVersion, 'Q')
    writer.write(self._fmtVersion, 'Q')
    writer.write_string(self._metadata, 'B')
    writer.write_string(self._jsonDoc, 'I')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._docVersion == other._docVersion and
        self._fmtVersion == other._fmtVersion and
        self._metadata == other._metadata and
        self._jsonDoc == other._jsonDoc)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._docVersion, 'Q') +
      msgbuffers.size(self._fmtVersion, 'Q') +
      msgbuffers.size_string(self._metadata, 'B') +
      msgbuffers.size_string(self._jsonDoc, 'I'))

  def __str__(self):
    return '{type}(docVersion={docVersion}, fmtVersion={fmtVersion}, metadata={metadata}, jsonDoc={jsonDoc})'.format(
      type=type(self).__name__,
      docVersion=self._docVersion,
      fmtVersion=self._fmtVersion,
      metadata=msgbuffers.shorten_string(self._metadata),
      jsonDoc=msgbuffers.shorten_string(self._jsonDoc))

  def __repr__(self):
    return '{type}(docVersion={docVersion}, fmtVersion={fmtVersion}, metadata={metadata}, jsonDoc={jsonDoc})'.format(
      type=type(self).__name__,
      docVersion=repr(self._docVersion),
      fmtVersion=repr(self._fmtVersion),
      metadata=repr(self._metadata),
      jsonDoc=repr(self._jsonDoc))

Anki.Vector.JDocs.Doc = Doc
del Doc


class WriteRequest(object):
  "Generated message-passing structure."

  __slots__ = (
    '_account', # string[uint_16]
    '_thing',   # string[uint_16]
    '_docName', # string[uint_16]
    '_doc',     # Anki.Vector.JDocs.Doc
  )

  @property
  def account(self):
    "string[uint_16] account struct property."
    return self._account

  @account.setter
  def account(self, value):
    self._account = msgbuffers.validate_string(
      'WriteRequest.account', value, 65535)

  @property
  def thing(self):
    "string[uint_16] thing struct property."
    return self._thing

  @thing.setter
  def thing(self, value):
    self._thing = msgbuffers.validate_string(
      'WriteRequest.thing', value, 65535)

  @property
  def docName(self):
    "string[uint_16] docName struct property."
    return self._docName

  @docName.setter
  def docName(self, value):
    self._docName = msgbuffers.validate_string(
      'WriteRequest.docName', value, 65535)

  @property
  def doc(self):
    "Anki.Vector.JDocs.Doc doc struct property."
    return self._doc

  @doc.setter
  def doc(self, value):
    self._doc = msgbuffers.validate_object(
      'WriteRequest.doc', value, Anki.Vector.JDocs.Doc)

  def __init__(self, account='', thing='', docName='', doc=Anki.Vector.JDocs.Doc()):
    self.account = account
    self.thing = thing
    self.docName = docName
    self.doc = doc

  @classmethod
  def unpack(cls, buffer):
    "Reads a new WriteRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('WriteRequest.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new WriteRequest from the given BinaryReader."
    _account = reader.read_string('H')
    _thing = reader.read_string('H')
    _docName = reader.read_string('H')
    _doc = reader.read_object(Anki.Vector.JDocs.Doc.unpack_from)
    return cls(_account, _thing, _docName, _doc)

  def pack(self):
    "Writes the current WriteRequest, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current WriteRequest to the given BinaryWriter."
    writer.write_string(self._account, 'H')
    writer.write_string(self._thing, 'H')
    writer.write_string(self._docName, 'H')
    writer.write_object(self._doc)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._account == other._account and
        self._thing == other._thing and
        self._docName == other._docName and
        self._doc == other._doc)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._account, 'H') +
      msgbuffers.size_string(self._thing, 'H') +
      msgbuffers.size_string(self._docName, 'H') +
      msgbuffers.size_object(self._doc))

  def __str__(self):
    return '{type}(account={account}, thing={thing}, docName={docName}, doc={doc})'.format(
      type=type(self).__name__,
      account=msgbuffers.shorten_string(self._account),
      thing=msgbuffers.shorten_string(self._thing),
      docName=msgbuffers.shorten_string(self._docName),
      doc=self._doc)

  def __repr__(self):
    return '{type}(account={account}, thing={thing}, docName={docName}, doc={doc})'.format(
      type=type(self).__name__,
      account=repr(self._account),
      thing=repr(self._thing),
      docName=repr(self._docName),
      doc=repr(self._doc))

Anki.Vector.JDocs.WriteRequest = WriteRequest
del WriteRequest


class DocError(object):
  "Automatically-generated uint_8 enumeration."
  ErrorConnecting = 0

Anki.Vector.JDocs.DocError = DocError
del DocError


class WriteStatus(object):
  "Automatically-generated uint_8 enumeration."
  Accepted           = 0
  RejectedDocVersion = 1
  RejectedFmtVersion = 2
  Error              = 3

Anki.Vector.JDocs.WriteStatus = WriteStatus
del WriteStatus


class WriteResponse(object):
  "Generated message-passing structure."

  __slots__ = (
    '_status',        # Anki.Vector.JDocs.WriteStatus
    '_latestVersion', # uint_64
  )

  @property
  def status(self):
    "Anki.Vector.JDocs.WriteStatus status struct property."
    return self._status

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_integer(
      'WriteResponse.status', value, 0, 255)

  @property
  def latestVersion(self):
    "uint_64 latestVersion struct property."
    return self._latestVersion

  @latestVersion.setter
  def latestVersion(self, value):
    self._latestVersion = msgbuffers.validate_integer(
      'WriteResponse.latestVersion', value, 0, 18446744073709551615)

  def __init__(self, status=Anki.Vector.JDocs.WriteStatus.Accepted, latestVersion=0):
    self.status = status
    self.latestVersion = latestVersion

  @classmethod
  def unpack(cls, buffer):
    "Reads a new WriteResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('WriteResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new WriteResponse from the given BinaryReader."
    _status = reader.read('B')
    _latestVersion = reader.read('Q')
    return cls(_status, _latestVersion)

  def pack(self):
    "Writes the current WriteResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current WriteResponse to the given BinaryWriter."
    writer.write(self._status, 'B')
    writer.write(self._latestVersion, 'Q')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._status == other._status and
        self._latestVersion == other._latestVersion)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._status, 'B') +
      msgbuffers.size(self._latestVersion, 'Q'))

  def __str__(self):
    return '{type}(status={status}, latestVersion={latestVersion})'.format(
      type=type(self).__name__,
      status=self._status,
      latestVersion=self._latestVersion)

  def __repr__(self):
    return '{type}(status={status}, latestVersion={latestVersion})'.format(
      type=type(self).__name__,
      status=repr(self._status),
      latestVersion=repr(self._latestVersion))

Anki.Vector.JDocs.WriteResponse = WriteResponse
del WriteResponse


class ReadItem(object):
  "Generated message-passing structure."

  __slots__ = (
    '_docName',      # string[uint_8]
    '_myDocVersion', # uint_64
  )

  @property
  def docName(self):
    "string[uint_8] docName struct property."
    return self._docName

  @docName.setter
  def docName(self, value):
    self._docName = msgbuffers.validate_string(
      'ReadItem.docName', value, 255)

  @property
  def myDocVersion(self):
    "uint_64 myDocVersion struct property."
    return self._myDocVersion

  @myDocVersion.setter
  def myDocVersion(self, value):
    self._myDocVersion = msgbuffers.validate_integer(
      'ReadItem.myDocVersion', value, 0, 18446744073709551615)

  def __init__(self, docName='', myDocVersion=0):
    self.docName = docName
    self.myDocVersion = myDocVersion

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ReadItem from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ReadItem.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ReadItem from the given BinaryReader."
    _docName = reader.read_string('B')
    _myDocVersion = reader.read('Q')
    return cls(_docName, _myDocVersion)

  def pack(self):
    "Writes the current ReadItem, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ReadItem to the given BinaryWriter."
    writer.write_string(self._docName, 'B')
    writer.write(self._myDocVersion, 'Q')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._docName == other._docName and
        self._myDocVersion == other._myDocVersion)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._docName, 'B') +
      msgbuffers.size(self._myDocVersion, 'Q'))

  def __str__(self):
    return '{type}(docName={docName}, myDocVersion={myDocVersion})'.format(
      type=type(self).__name__,
      docName=msgbuffers.shorten_string(self._docName),
      myDocVersion=self._myDocVersion)

  def __repr__(self):
    return '{type}(docName={docName}, myDocVersion={myDocVersion})'.format(
      type=type(self).__name__,
      docName=repr(self._docName),
      myDocVersion=repr(self._myDocVersion))

Anki.Vector.JDocs.ReadItem = ReadItem
del ReadItem


class ReadRequest(object):
  "Generated message-passing structure."

  __slots__ = (
    '_account', # string[uint_16]
    '_thing',   # string[uint_16]
    '_items',   # ReadItem[uint_16]
  )

  @property
  def account(self):
    "string[uint_16] account struct property."
    return self._account

  @account.setter
  def account(self, value):
    self._account = msgbuffers.validate_string(
      'ReadRequest.account', value, 65535)

  @property
  def thing(self):
    "string[uint_16] thing struct property."
    return self._thing

  @thing.setter
  def thing(self, value):
    self._thing = msgbuffers.validate_string(
      'ReadRequest.thing', value, 65535)

  @property
  def items(self):
    "ReadItem[uint_16] items struct property."
    return self._items

  @items.setter
  def items(self, value):
    self._items = msgbuffers.validate_varray(
      'ReadRequest.items', value, 65535,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.JDocs.ReadItem))

  def __init__(self, account='', thing='', items=()):
    self.account = account
    self.thing = thing
    self.items = items

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ReadRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ReadRequest.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ReadRequest from the given BinaryReader."
    _account = reader.read_string('H')
    _thing = reader.read_string('H')
    _items = reader.read_object_varray(Anki.Vector.JDocs.ReadItem.unpack_from, 'H')
    return cls(_account, _thing, _items)

  def pack(self):
    "Writes the current ReadRequest, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ReadRequest to the given BinaryWriter."
    writer.write_string(self._account, 'H')
    writer.write_string(self._thing, 'H')
    writer.write_object_varray(self._items, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._account == other._account and
        self._thing == other._thing and
        self._items == other._items)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._account, 'H') +
      msgbuffers.size_string(self._thing, 'H') +
      msgbuffers.size_object_varray(self._items, 'H'))

  def __str__(self):
    return '{type}(account={account}, thing={thing}, items={items})'.format(
      type=type(self).__name__,
      account=msgbuffers.shorten_string(self._account),
      thing=msgbuffers.shorten_string(self._thing),
      items=msgbuffers.shorten_sequence(self._items))

  def __repr__(self):
    return '{type}(account={account}, thing={thing}, items={items})'.format(
      type=type(self).__name__,
      account=repr(self._account),
      thing=repr(self._thing),
      items=repr(self._items))

Anki.Vector.JDocs.ReadRequest = ReadRequest
del ReadRequest


class ReadStatus(object):
  "Automatically-generated uint_8 enumeration."
  Unchanged        = 0
  Changed          = 1
  NotFound         = 2
  PermissionDenied = 3

Anki.Vector.JDocs.ReadStatus = ReadStatus
del ReadStatus


class ResponseDoc(object):
  "Generated message-passing structure."

  __slots__ = (
    '_status', # Anki.Vector.JDocs.ReadStatus
    '_doc',    # Anki.Vector.JDocs.Doc
  )

  @property
  def status(self):
    "Anki.Vector.JDocs.ReadStatus status struct property."
    return self._status

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_integer(
      'ResponseDoc.status', value, 0, 255)

  @property
  def doc(self):
    "Anki.Vector.JDocs.Doc doc struct property."
    return self._doc

  @doc.setter
  def doc(self, value):
    self._doc = msgbuffers.validate_object(
      'ResponseDoc.doc', value, Anki.Vector.JDocs.Doc)

  def __init__(self, status=Anki.Vector.JDocs.ReadStatus.Unchanged, doc=Anki.Vector.JDocs.Doc()):
    self.status = status
    self.doc = doc

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ResponseDoc from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ResponseDoc.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ResponseDoc from the given BinaryReader."
    _status = reader.read('B')
    _doc = reader.read_object(Anki.Vector.JDocs.Doc.unpack_from)
    return cls(_status, _doc)

  def pack(self):
    "Writes the current ResponseDoc, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ResponseDoc to the given BinaryWriter."
    writer.write(self._status, 'B')
    writer.write_object(self._doc)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._status == other._status and
        self._doc == other._doc)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._status, 'B') +
      msgbuffers.size_object(self._doc))

  def __str__(self):
    return '{type}(status={status}, doc={doc})'.format(
      type=type(self).__name__,
      status=self._status,
      doc=self._doc)

  def __repr__(self):
    return '{type}(status={status}, doc={doc})'.format(
      type=type(self).__name__,
      status=repr(self._status),
      doc=repr(self._doc))

Anki.Vector.JDocs.ResponseDoc = ResponseDoc
del ResponseDoc


class ReadResponse(object):
  "Generated message-passing structure."

  __slots__ = (
    '_items', # ResponseDoc[uint_16]
  )

  @property
  def items(self):
    "ResponseDoc[uint_16] items struct property."
    return self._items

  @items.setter
  def items(self, value):
    self._items = msgbuffers.validate_varray(
      'ReadResponse.items', value, 65535,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.JDocs.ResponseDoc))

  def __init__(self, items=()):
    self.items = items

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ReadResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ReadResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ReadResponse from the given BinaryReader."
    _items = reader.read_object_varray(Anki.Vector.JDocs.ResponseDoc.unpack_from, 'H')
    return cls(_items)

  def pack(self):
    "Writes the current ReadResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ReadResponse to the given BinaryWriter."
    writer.write_object_varray(self._items, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._items == other._items
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_object_varray(self._items, 'H'))

  def __str__(self):
    return '{type}(items={items})'.format(
      type=type(self).__name__,
      items=msgbuffers.shorten_sequence(self._items))

  def __repr__(self):
    return '{type}(items={items})'.format(
      type=type(self).__name__,
      items=repr(self._items))

Anki.Vector.JDocs.ReadResponse = ReadResponse
del ReadResponse


class DeleteRequest(object):
  "Generated message-passing structure."

  __slots__ = (
    '_account', # string[uint_16]
    '_thing',   # string[uint_16]
    '_docName', # string[uint_16]
  )

  @property
  def account(self):
    "string[uint_16] account struct property."
    return self._account

  @account.setter
  def account(self, value):
    self._account = msgbuffers.validate_string(
      'DeleteRequest.account', value, 65535)

  @property
  def thing(self):
    "string[uint_16] thing struct property."
    return self._thing

  @thing.setter
  def thing(self, value):
    self._thing = msgbuffers.validate_string(
      'DeleteRequest.thing', value, 65535)

  @property
  def docName(self):
    "string[uint_16] docName struct property."
    return self._docName

  @docName.setter
  def docName(self, value):
    self._docName = msgbuffers.validate_string(
      'DeleteRequest.docName', value, 65535)

  def __init__(self, account='', thing='', docName=''):
    self.account = account
    self.thing = thing
    self.docName = docName

  @classmethod
  def unpack(cls, buffer):
    "Reads a new DeleteRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('DeleteRequest.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new DeleteRequest from the given BinaryReader."
    _account = reader.read_string('H')
    _thing = reader.read_string('H')
    _docName = reader.read_string('H')
    return cls(_account, _thing, _docName)

  def pack(self):
    "Writes the current DeleteRequest, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current DeleteRequest to the given BinaryWriter."
    writer.write_string(self._account, 'H')
    writer.write_string(self._thing, 'H')
    writer.write_string(self._docName, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._account == other._account and
        self._thing == other._thing and
        self._docName == other._docName)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._account, 'H') +
      msgbuffers.size_string(self._thing, 'H') +
      msgbuffers.size_string(self._docName, 'H'))

  def __str__(self):
    return '{type}(account={account}, thing={thing}, docName={docName})'.format(
      type=type(self).__name__,
      account=msgbuffers.shorten_string(self._account),
      thing=msgbuffers.shorten_string(self._thing),
      docName=msgbuffers.shorten_string(self._docName))

  def __repr__(self):
    return '{type}(account={account}, thing={thing}, docName={docName})'.format(
      type=type(self).__name__,
      account=repr(self._account),
      thing=repr(self._thing),
      docName=repr(self._docName))

Anki.Vector.JDocs.DeleteRequest = DeleteRequest
del DeleteRequest


class DocRequest(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    write     = 0 # Anki.Vector.JDocs.WriteRequest
    read      = 1 # Anki.Vector.JDocs.ReadRequest
    deleteReq = 2 # Anki.Vector.JDocs.DeleteRequest
    user      = 3 # Anki.Vector.Void
    thing     = 4 # Anki.Vector.Void

  @property
  def tag(self):
    "The current tag for this union."
    return self._tag

  @property
  def tag_name(self):
    "The name of the current tag for this union."
    if self._tag in self._tags_by_value:
      return self._tags_by_value[self._tag]
    else:
      return None

  @property
  def data(self):
    "The data held by this union. None if no data is set."
    return self._data

  @property
  def write(self):
    "Anki.Vector.JDocs.WriteRequest write union property."
    msgbuffers.safety_check_tag('write', self._tag, self.Tag.write, self._tags_by_value)
    return self._data

  @write.setter
  def write(self, value):
    self._data = msgbuffers.validate_object(
      'DocRequest.write', value, Anki.Vector.JDocs.WriteRequest)
    self._tag = self.Tag.write

  @property
  def read(self):
    "Anki.Vector.JDocs.ReadRequest read union property."
    msgbuffers.safety_check_tag('read', self._tag, self.Tag.read, self._tags_by_value)
    return self._data

  @read.setter
  def read(self, value):
    self._data = msgbuffers.validate_object(
      'DocRequest.read', value, Anki.Vector.JDocs.ReadRequest)
    self._tag = self.Tag.read

  @property
  def deleteReq(self):
    "Anki.Vector.JDocs.DeleteRequest deleteReq union property."
    msgbuffers.safety_check_tag('deleteReq', self._tag, self.Tag.deleteReq, self._tags_by_value)
    return self._data

  @deleteReq.setter
  def deleteReq(self, value):
    self._data = msgbuffers.validate_object(
      'DocRequest.deleteReq', value, Anki.Vector.JDocs.DeleteRequest)
    self._tag = self.Tag.deleteReq

  @property
  def user(self):
    "Anki.Vector.Void user union property."
    msgbuffers.safety_check_tag('user', self._tag, self.Tag.user, self._tags_by_value)
    return self._data

  @user.setter
  def user(self, value):
    self._data = msgbuffers.validate_object(
      'DocRequest.user', value, Anki.Vector.Void)
    self._tag = self.Tag.user

  @property
  def thing(self):
    "Anki.Vector.Void thing union property."
    msgbuffers.safety_check_tag('thing', self._tag, self.Tag.thing, self._tags_by_value)
    return self._data

  @thing.setter
  def thing(self, value):
    self._data = msgbuffers.validate_object(
      'DocRequest.thing', value, Anki.Vector.Void)
    self._tag = self.Tag.thing

  def __init__(self, **kwargs):
    if not kwargs:
      self._tag = None
      self._data = None

    elif len(kwargs) == 1:
      key, value = next(iter(kwargs.items()))
      if key not in self._tags_by_name:
        raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key))
      # calls the correct property
      setattr(self, key, value)

    else:
      raise TypeError('This method only accepts up to one keyword argument.')

  @classmethod
  def unpack(cls, buffer):
    "Reads a new DocRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('DocRequest.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new DocRequest from the given BinaryReader."
    tag = reader.read('B')
    if tag in cls._tags_by_value:
      value = cls()
      setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader))
      return value
    else:
      raise ValueError('DocRequest attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current DocRequest, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current SampleUnion to the given BinaryWriter."
    if self._tag in self._tags_by_value:
      writer.write(self._tag, 'B')
      self._tag_pack_methods[self._tag](writer, self._data)
    else:
      raise ValueError('Cannot pack an empty DocRequest.')

  def clear(self):
    self._tag = None
    self._data = None

  @classmethod
  def typeByTag(cls, tag):
    return cls._type_by_tag_value[tag]()

  def __eq__(self, other):
    if type(self) is type(other):
      return self._tag == other._tag and self._data == other._data
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    if 0 <= self._tag < 5:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 5:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=self._data)
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  def __repr__(self):
    if 0 <= self._tag < 5:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=repr(self._data))
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  _tags_by_name = dict(
    write=0,
    read=1,
    deleteReq=2,
    user=3,
    thing=4,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'write'
  _tags_by_value[1] = 'read'
  _tags_by_value[2] = 'deleteReq'
  _tags_by_value[3] = 'user'
  _tags_by_value[4] = 'thing'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.JDocs.WriteRequest.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.JDocs.ReadRequest.unpack_from)
  _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.JDocs.DeleteRequest.unpack_from)
  _tag_unpack_methods[3] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[4] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[0] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[1] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[2] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[3] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[4] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[2] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[3] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[4] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.JDocs.WriteRequest
  _type_by_tag_value[1] = lambda : Anki.Vector.JDocs.ReadRequest
  _type_by_tag_value[2] = lambda : Anki.Vector.JDocs.DeleteRequest
  _type_by_tag_value[3] = lambda : Anki.Vector.Void
  _type_by_tag_value[4] = lambda : Anki.Vector.Void
  

Anki.Vector.JDocs.DocRequest = DocRequest
del DocRequest


class ErrorResponse(object):
  "Generated message-passing structure."

  __slots__ = (
    '_err', # Anki.Vector.JDocs.DocError
  )

  @property
  def err(self):
    "Anki.Vector.JDocs.DocError err struct property."
    return self._err

  @err.setter
  def err(self, value):
    self._err = msgbuffers.validate_integer(
      'ErrorResponse.err', value, 0, 255)

  def __init__(self, err=Anki.Vector.JDocs.DocError.ErrorConnecting):
    self.err = err

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ErrorResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ErrorResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ErrorResponse from the given BinaryReader."
    _err = reader.read('B')
    return cls(_err)

  def pack(self):
    "Writes the current ErrorResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ErrorResponse to the given BinaryWriter."
    writer.write(self._err, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._err == other._err
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._err, 'B'))

  def __str__(self):
    return '{type}(err={err})'.format(
      type=type(self).__name__,
      err=self._err)

  def __repr__(self):
    return '{type}(err={err})'.format(
      type=type(self).__name__,
      err=repr(self._err))

Anki.Vector.JDocs.ErrorResponse = ErrorResponse
del ErrorResponse


class UserResponse(object):
  "Generated message-passing structure."

  __slots__ = (
    '_userId', # string[uint_8]
  )

  @property
  def userId(self):
    "string[uint_8] userId struct property."
    return self._userId

  @userId.setter
  def userId(self, value):
    self._userId = msgbuffers.validate_string(
      'UserResponse.userId', value, 255)

  def __init__(self, userId=''):
    self.userId = userId

  @classmethod
  def unpack(cls, buffer):
    "Reads a new UserResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('UserResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new UserResponse from the given BinaryReader."
    _userId = reader.read_string('B')
    return cls(_userId)

  def pack(self):
    "Writes the current UserResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current UserResponse to the given BinaryWriter."
    writer.write_string(self._userId, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._userId == other._userId
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._userId, 'B'))

  def __str__(self):
    return '{type}(userId={userId})'.format(
      type=type(self).__name__,
      userId=msgbuffers.shorten_string(self._userId))

  def __repr__(self):
    return '{type}(userId={userId})'.format(
      type=type(self).__name__,
      userId=repr(self._userId))

Anki.Vector.JDocs.UserResponse = UserResponse
del UserResponse


class ThingResponse(object):
  "Generated message-passing structure."

  __slots__ = (
    '_thingName', # string[uint_8]
  )

  @property
  def thingName(self):
    "string[uint_8] thingName struct property."
    return self._thingName

  @thingName.setter
  def thingName(self, value):
    self._thingName = msgbuffers.validate_string(
      'ThingResponse.thingName', value, 255)

  def __init__(self, thingName=''):
    self.thingName = thingName

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ThingResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ThingResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ThingResponse from the given BinaryReader."
    _thingName = reader.read_string('B')
    return cls(_thingName)

  def pack(self):
    "Writes the current ThingResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ThingResponse to the given BinaryWriter."
    writer.write_string(self._thingName, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._thingName == other._thingName
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._thingName, 'B'))

  def __str__(self):
    return '{type}(thingName={thingName})'.format(
      type=type(self).__name__,
      thingName=msgbuffers.shorten_string(self._thingName))

  def __repr__(self):
    return '{type}(thingName={thingName})'.format(
      type=type(self).__name__,
      thingName=repr(self._thingName))

Anki.Vector.JDocs.ThingResponse = ThingResponse
del ThingResponse


class DocResponse(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    write      = 0 # Anki.Vector.JDocs.WriteResponse
    read       = 1 # Anki.Vector.JDocs.ReadResponse
    deleteResp = 2 # Anki.Vector.Void
    err        = 3 # Anki.Vector.JDocs.ErrorResponse
    user       = 4 # Anki.Vector.JDocs.UserResponse
    thing      = 5 # Anki.Vector.JDocs.ThingResponse

  @property
  def tag(self):
    "The current tag for this union."
    return self._tag

  @property
  def tag_name(self):
    "The name of the current tag for this union."
    if self._tag in self._tags_by_value:
      return self._tags_by_value[self._tag]
    else:
      return None

  @property
  def data(self):
    "The data held by this union. None if no data is set."
    return self._data

  @property
  def write(self):
    "Anki.Vector.JDocs.WriteResponse write union property."
    msgbuffers.safety_check_tag('write', self._tag, self.Tag.write, self._tags_by_value)
    return self._data

  @write.setter
  def write(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.write', value, Anki.Vector.JDocs.WriteResponse)
    self._tag = self.Tag.write

  @property
  def read(self):
    "Anki.Vector.JDocs.ReadResponse read union property."
    msgbuffers.safety_check_tag('read', self._tag, self.Tag.read, self._tags_by_value)
    return self._data

  @read.setter
  def read(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.read', value, Anki.Vector.JDocs.ReadResponse)
    self._tag = self.Tag.read

  @property
  def deleteResp(self):
    "Anki.Vector.Void deleteResp union property."
    msgbuffers.safety_check_tag('deleteResp', self._tag, self.Tag.deleteResp, self._tags_by_value)
    return self._data

  @deleteResp.setter
  def deleteResp(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.deleteResp', value, Anki.Vector.Void)
    self._tag = self.Tag.deleteResp

  @property
  def err(self):
    "Anki.Vector.JDocs.ErrorResponse err union property."
    msgbuffers.safety_check_tag('err', self._tag, self.Tag.err, self._tags_by_value)
    return self._data

  @err.setter
  def err(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.err', value, Anki.Vector.JDocs.ErrorResponse)
    self._tag = self.Tag.err

  @property
  def user(self):
    "Anki.Vector.JDocs.UserResponse user union property."
    msgbuffers.safety_check_tag('user', self._tag, self.Tag.user, self._tags_by_value)
    return self._data

  @user.setter
  def user(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.user', value, Anki.Vector.JDocs.UserResponse)
    self._tag = self.Tag.user

  @property
  def thing(self):
    "Anki.Vector.JDocs.ThingResponse thing union property."
    msgbuffers.safety_check_tag('thing', self._tag, self.Tag.thing, self._tags_by_value)
    return self._data

  @thing.setter
  def thing(self, value):
    self._data = msgbuffers.validate_object(
      'DocResponse.thing', value, Anki.Vector.JDocs.ThingResponse)
    self._tag = self.Tag.thing

  def __init__(self, **kwargs):
    if not kwargs:
      self._tag = None
      self._data = None

    elif len(kwargs) == 1:
      key, value = next(iter(kwargs.items()))
      if key not in self._tags_by_name:
        raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key))
      # calls the correct property
      setattr(self, key, value)

    else:
      raise TypeError('This method only accepts up to one keyword argument.')

  @classmethod
  def unpack(cls, buffer):
    "Reads a new DocResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('DocResponse.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new DocResponse from the given BinaryReader."
    tag = reader.read('B')
    if tag in cls._tags_by_value:
      value = cls()
      setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader))
      return value
    else:
      raise ValueError('DocResponse attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current DocResponse, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current SampleUnion to the given BinaryWriter."
    if self._tag in self._tags_by_value:
      writer.write(self._tag, 'B')
      self._tag_pack_methods[self._tag](writer, self._data)
    else:
      raise ValueError('Cannot pack an empty DocResponse.')

  def clear(self):
    self._tag = None
    self._data = None

  @classmethod
  def typeByTag(cls, tag):
    return cls._type_by_tag_value[tag]()

  def __eq__(self, other):
    if type(self) is type(other):
      return self._tag == other._tag and self._data == other._data
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    if 0 <= self._tag < 6:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 6:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=self._data)
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  def __repr__(self):
    if 0 <= self._tag < 6:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=repr(self._data))
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  _tags_by_name = dict(
    write=0,
    read=1,
    deleteResp=2,
    err=3,
    user=4,
    thing=5,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'write'
  _tags_by_value[1] = 'read'
  _tags_by_value[2] = 'deleteResp'
  _tags_by_value[3] = 'err'
  _tags_by_value[4] = 'user'
  _tags_by_value[5] = 'thing'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.JDocs.WriteResponse.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.JDocs.ReadResponse.unpack_from)
  _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[3] = lambda reader: reader.read_object(Anki.Vector.JDocs.ErrorResponse.unpack_from)
  _tag_unpack_methods[4] = lambda reader: reader.read_object(Anki.Vector.JDocs.UserResponse.unpack_from)
  _tag_unpack_methods[5] = lambda reader: reader.read_object(Anki.Vector.JDocs.ThingResponse.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[0] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[1] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[2] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[3] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[4] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[5] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[2] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[3] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[4] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[5] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.JDocs.WriteResponse
  _type_by_tag_value[1] = lambda : Anki.Vector.JDocs.ReadResponse
  _type_by_tag_value[2] = lambda : Anki.Vector.Void
  _type_by_tag_value[3] = lambda : Anki.Vector.JDocs.ErrorResponse
  _type_by_tag_value[4] = lambda : Anki.Vector.JDocs.UserResponse
  _type_by_tag_value[5] = lambda : Anki.Vector.JDocs.ThingResponse
  

Anki.Vector.JDocs.DocResponse = DocResponse
del DocResponse