"""
Autogenerated python message buffer code.
Source: clad/cloud/token.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/token.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()

class TokenError(object):
  "Automatically-generated uint_8 enumeration."
  NoError      = 0
  NullToken    = 1
  InvalidToken = 2
  Connection   = 3
  WrongAccount = 4

Anki.Vector.TokenError = TokenError
del TokenError


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

  __slots__ = (
    '_sessionToken', # string[uint_8]
    '_clientName',   # string[uint_8]
    '_appId',        # string[uint_8]
  )

  @property
  def sessionToken(self):
    "string[uint_8] sessionToken struct property."
    return self._sessionToken

  @sessionToken.setter
  def sessionToken(self, value):
    self._sessionToken = msgbuffers.validate_string(
      'AuthRequest.sessionToken', value, 255)

  @property
  def clientName(self):
    "string[uint_8] clientName struct property."
    return self._clientName

  @clientName.setter
  def clientName(self, value):
    self._clientName = msgbuffers.validate_string(
      'AuthRequest.clientName', value, 255)

  @property
  def appId(self):
    "string[uint_8] appId struct property."
    return self._appId

  @appId.setter
  def appId(self, value):
    self._appId = msgbuffers.validate_string(
      'AuthRequest.appId', value, 255)

  def __init__(self, sessionToken='', clientName='', appId=''):
    self.sessionToken = sessionToken
    self.clientName = clientName
    self.appId = appId

  @classmethod
  def unpack(cls, buffer):
    "Reads a new AuthRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('AuthRequest.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 AuthRequest from the given BinaryReader."
    _sessionToken = reader.read_string('B')
    _clientName = reader.read_string('B')
    _appId = reader.read_string('B')
    return cls(_sessionToken, _clientName, _appId)

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

  def pack_to(self, writer):
    "Writes the current AuthRequest to the given BinaryWriter."
    writer.write_string(self._sessionToken, 'B')
    writer.write_string(self._clientName, 'B')
    writer.write_string(self._appId, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._sessionToken == other._sessionToken and
        self._clientName == other._clientName and
        self._appId == other._appId)
    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._sessionToken, 'B') +
      msgbuffers.size_string(self._clientName, 'B') +
      msgbuffers.size_string(self._appId, 'B'))

  def __str__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=msgbuffers.shorten_string(self._sessionToken),
      clientName=msgbuffers.shorten_string(self._clientName),
      appId=msgbuffers.shorten_string(self._appId))

  def __repr__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=repr(self._sessionToken),
      clientName=repr(self._clientName),
      appId=repr(self._appId))

Anki.Vector.AuthRequest = AuthRequest
del AuthRequest


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

  __slots__ = (
    '_appToken', # string[uint_16]
    '_jwtToken', # string[uint_16]
    '_error',    # Anki.Vector.TokenError
  )

  @property
  def appToken(self):
    "string[uint_16] appToken struct property."
    return self._appToken

  @appToken.setter
  def appToken(self, value):
    self._appToken = msgbuffers.validate_string(
      'AuthResponse.appToken', value, 65535)

  @property
  def jwtToken(self):
    "string[uint_16] jwtToken struct property."
    return self._jwtToken

  @jwtToken.setter
  def jwtToken(self, value):
    self._jwtToken = msgbuffers.validate_string(
      'AuthResponse.jwtToken', value, 65535)

  @property
  def error(self):
    "Anki.Vector.TokenError error struct property."
    return self._error

  @error.setter
  def error(self, value):
    self._error = msgbuffers.validate_integer(
      'AuthResponse.error', value, 0, 255)

  def __init__(self, appToken='', jwtToken='', error=Anki.Vector.TokenError.NoError):
    self.appToken = appToken
    self.jwtToken = jwtToken
    self.error = error

  @classmethod
  def unpack(cls, buffer):
    "Reads a new AuthResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('AuthResponse.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 AuthResponse from the given BinaryReader."
    _appToken = reader.read_string('H')
    _jwtToken = reader.read_string('H')
    _error = reader.read('B')
    return cls(_appToken, _jwtToken, _error)

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

  def pack_to(self, writer):
    "Writes the current AuthResponse to the given BinaryWriter."
    writer.write_string(self._appToken, 'H')
    writer.write_string(self._jwtToken, 'H')
    writer.write(self._error, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._appToken == other._appToken and
        self._jwtToken == other._jwtToken and
        self._error == other._error)
    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._appToken, 'H') +
      msgbuffers.size_string(self._jwtToken, 'H') +
      msgbuffers.size(self._error, 'B'))

  def __str__(self):
    return '{type}(appToken={appToken}, jwtToken={jwtToken}, error={error})'.format(
      type=type(self).__name__,
      appToken=msgbuffers.shorten_string(self._appToken),
      jwtToken=msgbuffers.shorten_string(self._jwtToken),
      error=self._error)

  def __repr__(self):
    return '{type}(appToken={appToken}, jwtToken={jwtToken}, error={error})'.format(
      type=type(self).__name__,
      appToken=repr(self._appToken),
      jwtToken=repr(self._jwtToken),
      error=repr(self._error))

Anki.Vector.AuthResponse = AuthResponse
del AuthResponse


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

  __slots__ = (
    '_sessionToken', # string[uint_8]
    '_clientName',   # string[uint_8]
    '_appId',        # string[uint_8]
  )

  @property
  def sessionToken(self):
    "string[uint_8] sessionToken struct property."
    return self._sessionToken

  @sessionToken.setter
  def sessionToken(self, value):
    self._sessionToken = msgbuffers.validate_string(
      'ReassociateRequest.sessionToken', value, 255)

  @property
  def clientName(self):
    "string[uint_8] clientName struct property."
    return self._clientName

  @clientName.setter
  def clientName(self, value):
    self._clientName = msgbuffers.validate_string(
      'ReassociateRequest.clientName', value, 255)

  @property
  def appId(self):
    "string[uint_8] appId struct property."
    return self._appId

  @appId.setter
  def appId(self, value):
    self._appId = msgbuffers.validate_string(
      'ReassociateRequest.appId', value, 255)

  def __init__(self, sessionToken='', clientName='', appId=''):
    self.sessionToken = sessionToken
    self.clientName = clientName
    self.appId = appId

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ReassociateRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ReassociateRequest.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 ReassociateRequest from the given BinaryReader."
    _sessionToken = reader.read_string('B')
    _clientName = reader.read_string('B')
    _appId = reader.read_string('B')
    return cls(_sessionToken, _clientName, _appId)

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

  def pack_to(self, writer):
    "Writes the current ReassociateRequest to the given BinaryWriter."
    writer.write_string(self._sessionToken, 'B')
    writer.write_string(self._clientName, 'B')
    writer.write_string(self._appId, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._sessionToken == other._sessionToken and
        self._clientName == other._clientName and
        self._appId == other._appId)
    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._sessionToken, 'B') +
      msgbuffers.size_string(self._clientName, 'B') +
      msgbuffers.size_string(self._appId, 'B'))

  def __str__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=msgbuffers.shorten_string(self._sessionToken),
      clientName=msgbuffers.shorten_string(self._clientName),
      appId=msgbuffers.shorten_string(self._appId))

  def __repr__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=repr(self._sessionToken),
      clientName=repr(self._clientName),
      appId=repr(self._appId))

Anki.Vector.ReassociateRequest = ReassociateRequest
del ReassociateRequest


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

  __slots__ = (
    '_sessionToken', # string[uint_8]
    '_clientName',   # string[uint_8]
    '_appId',        # string[uint_8]
  )

  @property
  def sessionToken(self):
    "string[uint_8] sessionToken struct property."
    return self._sessionToken

  @sessionToken.setter
  def sessionToken(self, value):
    self._sessionToken = msgbuffers.validate_string(
      'SecondaryAuthRequest.sessionToken', value, 255)

  @property
  def clientName(self):
    "string[uint_8] clientName struct property."
    return self._clientName

  @clientName.setter
  def clientName(self, value):
    self._clientName = msgbuffers.validate_string(
      'SecondaryAuthRequest.clientName', value, 255)

  @property
  def appId(self):
    "string[uint_8] appId struct property."
    return self._appId

  @appId.setter
  def appId(self, value):
    self._appId = msgbuffers.validate_string(
      'SecondaryAuthRequest.appId', value, 255)

  def __init__(self, sessionToken='', clientName='', appId=''):
    self.sessionToken = sessionToken
    self.clientName = clientName
    self.appId = appId

  @classmethod
  def unpack(cls, buffer):
    "Reads a new SecondaryAuthRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('SecondaryAuthRequest.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 SecondaryAuthRequest from the given BinaryReader."
    _sessionToken = reader.read_string('B')
    _clientName = reader.read_string('B')
    _appId = reader.read_string('B')
    return cls(_sessionToken, _clientName, _appId)

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

  def pack_to(self, writer):
    "Writes the current SecondaryAuthRequest to the given BinaryWriter."
    writer.write_string(self._sessionToken, 'B')
    writer.write_string(self._clientName, 'B')
    writer.write_string(self._appId, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._sessionToken == other._sessionToken and
        self._clientName == other._clientName and
        self._appId == other._appId)
    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._sessionToken, 'B') +
      msgbuffers.size_string(self._clientName, 'B') +
      msgbuffers.size_string(self._appId, 'B'))

  def __str__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=msgbuffers.shorten_string(self._sessionToken),
      clientName=msgbuffers.shorten_string(self._clientName),
      appId=msgbuffers.shorten_string(self._appId))

  def __repr__(self):
    return '{type}(sessionToken={sessionToken}, clientName={clientName}, appId={appId})'.format(
      type=type(self).__name__,
      sessionToken=repr(self._sessionToken),
      clientName=repr(self._clientName),
      appId=repr(self._appId))

Anki.Vector.SecondaryAuthRequest = SecondaryAuthRequest
del SecondaryAuthRequest


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

  __slots__ = (
    '_forceRefresh', # bool
  )

  @property
  def forceRefresh(self):
    "bool forceRefresh struct property."
    return self._forceRefresh

  @forceRefresh.setter
  def forceRefresh(self, value):
    self._forceRefresh = msgbuffers.validate_bool(
      'JwtRequest.forceRefresh', value)

  def __init__(self, forceRefresh=False):
    self.forceRefresh = forceRefresh

  @classmethod
  def unpack(cls, buffer):
    "Reads a new JwtRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('JwtRequest.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 JwtRequest from the given BinaryReader."
    _forceRefresh = bool(reader.read('b'))
    return cls(_forceRefresh)

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

  def pack_to(self, writer):
    "Writes the current JwtRequest to the given BinaryWriter."
    writer.write(int(self._forceRefresh), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._forceRefresh == other._forceRefresh
    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._forceRefresh, 'b'))

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

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

Anki.Vector.JwtRequest = JwtRequest
del JwtRequest


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

  __slots__ = (
    '_jwtToken', # string[uint_16]
    '_error',    # Anki.Vector.TokenError
  )

  @property
  def jwtToken(self):
    "string[uint_16] jwtToken struct property."
    return self._jwtToken

  @jwtToken.setter
  def jwtToken(self, value):
    self._jwtToken = msgbuffers.validate_string(
      'JwtResponse.jwtToken', value, 65535)

  @property
  def error(self):
    "Anki.Vector.TokenError error struct property."
    return self._error

  @error.setter
  def error(self, value):
    self._error = msgbuffers.validate_integer(
      'JwtResponse.error', value, 0, 255)

  def __init__(self, jwtToken='', error=Anki.Vector.TokenError.NoError):
    self.jwtToken = jwtToken
    self.error = error

  @classmethod
  def unpack(cls, buffer):
    "Reads a new JwtResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('JwtResponse.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 JwtResponse from the given BinaryReader."
    _jwtToken = reader.read_string('H')
    _error = reader.read('B')
    return cls(_jwtToken, _error)

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

  def pack_to(self, writer):
    "Writes the current JwtResponse to the given BinaryWriter."
    writer.write_string(self._jwtToken, 'H')
    writer.write(self._error, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._jwtToken == other._jwtToken and
        self._error == other._error)
    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._jwtToken, 'H') +
      msgbuffers.size(self._error, 'B'))

  def __str__(self):
    return '{type}(jwtToken={jwtToken}, error={error})'.format(
      type=type(self).__name__,
      jwtToken=msgbuffers.shorten_string(self._jwtToken),
      error=self._error)

  def __repr__(self):
    return '{type}(jwtToken={jwtToken}, error={error})'.format(
      type=type(self).__name__,
      jwtToken=repr(self._jwtToken),
      error=repr(self._error))

Anki.Vector.JwtResponse = JwtResponse
del JwtResponse


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

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    auth        = 0 # Anki.Vector.AuthRequest
    secondary   = 1 # Anki.Vector.SecondaryAuthRequest
    reassociate = 2 # Anki.Vector.ReassociateRequest
    jwt         = 3 # Anki.Vector.JwtRequest

  @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 auth(self):
    "Anki.Vector.AuthRequest auth union property."
    msgbuffers.safety_check_tag('auth', self._tag, self.Tag.auth, self._tags_by_value)
    return self._data

  @auth.setter
  def auth(self, value):
    self._data = msgbuffers.validate_object(
      'TokenRequest.auth', value, Anki.Vector.AuthRequest)
    self._tag = self.Tag.auth

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

  @secondary.setter
  def secondary(self, value):
    self._data = msgbuffers.validate_object(
      'TokenRequest.secondary', value, Anki.Vector.SecondaryAuthRequest)
    self._tag = self.Tag.secondary

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

  @reassociate.setter
  def reassociate(self, value):
    self._data = msgbuffers.validate_object(
      'TokenRequest.reassociate', value, Anki.Vector.ReassociateRequest)
    self._tag = self.Tag.reassociate

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

  @jwt.setter
  def jwt(self, value):
    self._data = msgbuffers.validate_object(
      'TokenRequest.jwt', value, Anki.Vector.JwtRequest)
    self._tag = self.Tag.jwt

  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 TokenRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('TokenRequest.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 TokenRequest 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('TokenRequest attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current TokenRequest, 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 TokenRequest.')

  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 < 4:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 4:
      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 < 4:
      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(
    auth=0,
    secondary=1,
    reassociate=2,
    jwt=3,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'auth'
  _tags_by_value[1] = 'secondary'
  _tags_by_value[2] = 'reassociate'
  _tags_by_value[3] = 'jwt'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.AuthRequest.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.SecondaryAuthRequest.unpack_from)
  _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.ReassociateRequest.unpack_from)
  _tag_unpack_methods[3] = lambda reader: reader.read_object(Anki.Vector.JwtRequest.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_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)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.AuthRequest
  _type_by_tag_value[1] = lambda : Anki.Vector.SecondaryAuthRequest
  _type_by_tag_value[2] = lambda : Anki.Vector.ReassociateRequest
  _type_by_tag_value[3] = lambda : Anki.Vector.JwtRequest
  

Anki.Vector.TokenRequest = TokenRequest
del TokenRequest


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

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    auth = 0 # Anki.Vector.AuthResponse
    jwt  = 1 # Anki.Vector.JwtResponse

  @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 auth(self):
    "Anki.Vector.AuthResponse auth union property."
    msgbuffers.safety_check_tag('auth', self._tag, self.Tag.auth, self._tags_by_value)
    return self._data

  @auth.setter
  def auth(self, value):
    self._data = msgbuffers.validate_object(
      'TokenResponse.auth', value, Anki.Vector.AuthResponse)
    self._tag = self.Tag.auth

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

  @jwt.setter
  def jwt(self, value):
    self._data = msgbuffers.validate_object(
      'TokenResponse.jwt', value, Anki.Vector.JwtResponse)
    self._tag = self.Tag.jwt

  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 TokenResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('TokenResponse.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 TokenResponse 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('TokenResponse attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current TokenResponse, 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 TokenResponse.')

  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 < 2:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 2:
      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 < 2:
      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(
    auth=0,
    jwt=1,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'auth'
  _tags_by_value[1] = 'jwt'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.AuthResponse.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.JwtResponse.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_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.AuthResponse
  _type_by_tag_value[1] = lambda : Anki.Vector.JwtResponse
  

Anki.Vector.TokenResponse = TokenResponse
del TokenResponse