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

from clad.types.animationEvents import Anki as _Anki
Anki.update(_Anki.deep_clone())

from clad.types.sdkAudioTypes import Anki as _Anki
Anki.update(_Anki.deep_clone())

from clad.types.textToSpeechTypes import Anki as _Anki
Anki.update(_Anki.deep_clone())

class ConnectionCode(object):
  "Automatically-generated uint_8 enumeration."
  Available    = 0
  Connectivity = 1
  Tls          = 2
  Auth         = 3
  Bandwidth    = 4

Anki.Vector.ConnectionCode = ConnectionCode
del ConnectionCode


class ReportCloudConnectivity(object):
  "Generated message-passing message."

  __slots__ = (
    '_code',            # Anki.Vector.ConnectionCode
    '_numPackets',      # uint_8
    '_expectedPackets', # uint_8
  )

  @property
  def code(self):
    "Anki.Vector.ConnectionCode code struct property."
    return self._code

  @code.setter
  def code(self, value):
    self._code = msgbuffers.validate_integer(
      'ReportCloudConnectivity.code', value, 0, 255)

  @property
  def numPackets(self):
    "uint_8 numPackets struct property."
    return self._numPackets

  @numPackets.setter
  def numPackets(self, value):
    self._numPackets = msgbuffers.validate_integer(
      'ReportCloudConnectivity.numPackets', value, 0, 255)

  @property
  def expectedPackets(self):
    "uint_8 expectedPackets struct property."
    return self._expectedPackets

  @expectedPackets.setter
  def expectedPackets(self, value):
    self._expectedPackets = msgbuffers.validate_integer(
      'ReportCloudConnectivity.expectedPackets', value, 0, 255)

  def __init__(self, code=Anki.Vector.ConnectionCode.Available, numPackets=0, expectedPackets=0):
    self.code = code
    self.numPackets = numPackets
    self.expectedPackets = expectedPackets

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

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

  def pack_to(self, writer):
    "Writes the current ReportCloudConnectivity to the given BinaryWriter."
    writer.write(self._code, 'B')
    writer.write(self._numPackets, 'B')
    writer.write(self._expectedPackets, 'B')

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

  def __str__(self):
    return '{type}(code={code}, numPackets={numPackets}, expectedPackets={expectedPackets})'.format(
      type=type(self).__name__,
      code=self._code,
      numPackets=self._numPackets,
      expectedPackets=self._expectedPackets)

  def __repr__(self):
    return '{type}(code={code}, numPackets={numPackets}, expectedPackets={expectedPackets})'.format(
      type=type(self).__name__,
      code=repr(self._code),
      numPackets=repr(self._numPackets),
      expectedPackets=repr(self._expectedPackets))

Anki.Vector.ReportCloudConnectivity = ReportCloudConnectivity
del ReportCloudConnectivity


class StartShutdownAnim(object):
  "Generated message-passing message."

  __slots__ = ()

  def __init__(self):
    pass

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

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

  def pack_to(self, writer):
    "Writes the current StartShutdownAnim to the given BinaryWriter."

  def __eq__(self, other):
    if type(self) is type(other):
      return True
    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 0

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

  def __repr__(self):
    return '{type}()'.format(type=type(self).__name__)

Anki.Vector.StartShutdownAnim = StartShutdownAnim
del StartShutdownAnim


class AnimationState(object):
  "Generated message-passing message."

  __slots__ = (
    '_lockedTracks', # uint_8
    '_tracksInUse',  # uint_8
  )

  @property
  def lockedTracks(self):
    "uint_8 lockedTracks struct property."
    return self._lockedTracks

  @lockedTracks.setter
  def lockedTracks(self, value):
    self._lockedTracks = msgbuffers.validate_integer(
      'AnimationState.lockedTracks', value, 0, 255)

  @property
  def tracksInUse(self):
    "uint_8 tracksInUse struct property."
    return self._tracksInUse

  @tracksInUse.setter
  def tracksInUse(self, value):
    self._tracksInUse = msgbuffers.validate_integer(
      'AnimationState.tracksInUse', value, 0, 255)

  def __init__(self, lockedTracks=0, tracksInUse=0):
    self.lockedTracks = lockedTracks
    self.tracksInUse = tracksInUse

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

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

  def pack_to(self, writer):
    "Writes the current AnimationState to the given BinaryWriter."
    writer.write(self._lockedTracks, 'B')
    writer.write(self._tracksInUse, 'B')

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

  def __str__(self):
    return '{type}(lockedTracks={lockedTracks}, tracksInUse={tracksInUse})'.format(
      type=type(self).__name__,
      lockedTracks=self._lockedTracks,
      tracksInUse=self._tracksInUse)

  def __repr__(self):
    return '{type}(lockedTracks={lockedTracks}, tracksInUse={tracksInUse})'.format(
      type=type(self).__name__,
      lockedTracks=repr(self._lockedTracks),
      tracksInUse=repr(self._tracksInUse))

Anki.Vector.AnimationState = AnimationState
del AnimationState


class AnimationAdded(object):
  "Generated message-passing message."

  __slots__ = (
    '_animLength', # uint_32
    '_animName',   # string[uint_8]
  )

  @property
  def animLength(self):
    "uint_32 animLength struct property."
    return self._animLength

  @animLength.setter
  def animLength(self, value):
    self._animLength = msgbuffers.validate_integer(
      'AnimationAdded.animLength', value, 0, 4294967295)

  @property
  def animName(self):
    "string[uint_8] animName struct property."
    return self._animName

  @animName.setter
  def animName(self, value):
    self._animName = msgbuffers.validate_string(
      'AnimationAdded.animName', value, 255)

  def __init__(self, animLength=0, animName=''):
    self.animLength = animLength
    self.animName = animName

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

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

  def pack_to(self, writer):
    "Writes the current AnimationAdded to the given BinaryWriter."
    writer.write(self._animLength, 'I')
    writer.write_string(self._animName, 'B')

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

  def __str__(self):
    return '{type}(animLength={animLength}, animName={animName})'.format(
      type=type(self).__name__,
      animLength=self._animLength,
      animName=msgbuffers.shorten_string(self._animName))

  def __repr__(self):
    return '{type}(animLength={animLength}, animName={animName})'.format(
      type=type(self).__name__,
      animLength=repr(self._animLength),
      animName=repr(self._animName))

Anki.Vector.AnimationAdded = AnimationAdded
del AnimationAdded


class AnimationStarted(object):
  "Generated message-passing message."

  __slots__ = (
    '_tag',      # uint_8
    '_animName', # string[uint_8]
  )

  @property
  def tag(self):
    "uint_8 tag struct property."
    return self._tag

  @tag.setter
  def tag(self, value):
    self._tag = msgbuffers.validate_integer(
      'AnimationStarted.tag', value, 0, 255)

  @property
  def animName(self):
    "string[uint_8] animName struct property."
    return self._animName

  @animName.setter
  def animName(self, value):
    self._animName = msgbuffers.validate_string(
      'AnimationStarted.animName', value, 255)

  def __init__(self, tag=0, animName=''):
    self.tag = tag
    self.animName = animName

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

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

  def pack_to(self, writer):
    "Writes the current AnimationStarted to the given BinaryWriter."
    writer.write(self._tag, 'B')
    writer.write_string(self._animName, 'B')

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

  def __str__(self):
    return '{type}(tag={tag}, animName={animName})'.format(
      type=type(self).__name__,
      tag=self._tag,
      animName=msgbuffers.shorten_string(self._animName))

  def __repr__(self):
    return '{type}(tag={tag}, animName={animName})'.format(
      type=type(self).__name__,
      tag=repr(self._tag),
      animName=repr(self._animName))

Anki.Vector.AnimationStarted = AnimationStarted
del AnimationStarted


class AnimationEnded(object):
  "Generated message-passing message."

  __slots__ = (
    '_streamTimeAnimEnded', # uint_32
    '_tag',                 # uint_8
    '_wasAborted',          # bool
    '_animName',            # string[uint_8]
  )

  @property
  def streamTimeAnimEnded(self):
    "uint_32 streamTimeAnimEnded struct property."
    return self._streamTimeAnimEnded

  @streamTimeAnimEnded.setter
  def streamTimeAnimEnded(self, value):
    self._streamTimeAnimEnded = msgbuffers.validate_integer(
      'AnimationEnded.streamTimeAnimEnded', value, 0, 4294967295)

  @property
  def tag(self):
    "uint_8 tag struct property."
    return self._tag

  @tag.setter
  def tag(self, value):
    self._tag = msgbuffers.validate_integer(
      'AnimationEnded.tag', value, 0, 255)

  @property
  def wasAborted(self):
    "bool wasAborted struct property."
    return self._wasAborted

  @wasAborted.setter
  def wasAborted(self, value):
    self._wasAborted = msgbuffers.validate_bool(
      'AnimationEnded.wasAborted', value)

  @property
  def animName(self):
    "string[uint_8] animName struct property."
    return self._animName

  @animName.setter
  def animName(self, value):
    self._animName = msgbuffers.validate_string(
      'AnimationEnded.animName', value, 255)

  def __init__(self, streamTimeAnimEnded=0, tag=0, wasAborted=False, animName=''):
    self.streamTimeAnimEnded = streamTimeAnimEnded
    self.tag = tag
    self.wasAborted = wasAborted
    self.animName = animName

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

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

  def pack_to(self, writer):
    "Writes the current AnimationEnded to the given BinaryWriter."
    writer.write(self._streamTimeAnimEnded, 'I')
    writer.write(self._tag, 'B')
    writer.write(int(self._wasAborted), 'b')
    writer.write_string(self._animName, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._streamTimeAnimEnded == other._streamTimeAnimEnded and
        self._tag == other._tag and
        self._wasAborted == other._wasAborted and
        self._animName == other._animName)
    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._streamTimeAnimEnded, 'I') +
      msgbuffers.size(self._tag, 'B') +
      msgbuffers.size(self._wasAborted, 'b') +
      msgbuffers.size_string(self._animName, 'B'))

  def __str__(self):
    return '{type}(streamTimeAnimEnded={streamTimeAnimEnded}, tag={tag}, wasAborted={wasAborted}, animName={animName})'.format(
      type=type(self).__name__,
      streamTimeAnimEnded=self._streamTimeAnimEnded,
      tag=self._tag,
      wasAborted=self._wasAborted,
      animName=msgbuffers.shorten_string(self._animName))

  def __repr__(self):
    return '{type}(streamTimeAnimEnded={streamTimeAnimEnded}, tag={tag}, wasAborted={wasAborted}, animName={animName})'.format(
      type=type(self).__name__,
      streamTimeAnimEnded=repr(self._streamTimeAnimEnded),
      tag=repr(self._tag),
      wasAborted=repr(self._wasAborted),
      animName=repr(self._animName))

Anki.Vector.AnimationEnded = AnimationEnded
del AnimationEnded


class AnimationEvent(object):
  "Generated message-passing message."

  __slots__ = (
    '_timestamp', # uint_32
    '_tag',       # uint_8
    '_event_id',  # Anki.Vector.AnimEvent
  )

  @property
  def timestamp(self):
    "uint_32 timestamp struct property."
    return self._timestamp

  @timestamp.setter
  def timestamp(self, value):
    self._timestamp = msgbuffers.validate_integer(
      'AnimationEvent.timestamp', value, 0, 4294967295)

  @property
  def tag(self):
    "uint_8 tag struct property."
    return self._tag

  @tag.setter
  def tag(self, value):
    self._tag = msgbuffers.validate_integer(
      'AnimationEvent.tag', value, 0, 255)

  @property
  def event_id(self):
    "Anki.Vector.AnimEvent event_id struct property."
    return self._event_id

  @event_id.setter
  def event_id(self, value):
    self._event_id = msgbuffers.validate_integer(
      'AnimationEvent.event_id', value, 0, 255)

  def __init__(self, timestamp=0, tag=0, event_id=Anki.Vector.AnimEvent.DEVICE_AUDIO_TRIGGER):
    self.timestamp = timestamp
    self.tag = tag
    self.event_id = event_id

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

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

  def pack_to(self, writer):
    "Writes the current AnimationEvent to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(self._tag, 'B')
    writer.write(self._event_id, 'B')

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

  def __str__(self):
    return '{type}(timestamp={timestamp}, tag={tag}, event_id={event_id})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      tag=self._tag,
      event_id=self._event_id)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, tag={tag}, event_id={event_id})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      tag=repr(self._tag),
      event_id=repr(self._event_id))

Anki.Vector.AnimationEvent = AnimationEvent
del AnimationEvent


class TextToSpeechEvent(object):
  "Generated message-passing message."

  __slots__ = (
    '_expectedDuration_ms', # float_32
    '_ttsID',               # uint_8
    '_ttsState',            # Anki.Vector.TextToSpeechState
  )

  @property
  def expectedDuration_ms(self):
    "float_32 expectedDuration_ms struct property."
    return self._expectedDuration_ms

  @expectedDuration_ms.setter
  def expectedDuration_ms(self, value):
    self._expectedDuration_ms = msgbuffers.validate_float(
      'TextToSpeechEvent.expectedDuration_ms', value, 'f')

  @property
  def ttsID(self):
    "uint_8 ttsID struct property."
    return self._ttsID

  @ttsID.setter
  def ttsID(self, value):
    self._ttsID = msgbuffers.validate_integer(
      'TextToSpeechEvent.ttsID', value, 0, 255)

  @property
  def ttsState(self):
    "Anki.Vector.TextToSpeechState ttsState struct property."
    return self._ttsState

  @ttsState.setter
  def ttsState(self, value):
    self._ttsState = msgbuffers.validate_integer(
      'TextToSpeechEvent.ttsState', value, 0, 255)

  def __init__(self, expectedDuration_ms=0.0, ttsID=0, ttsState=Anki.Vector.TextToSpeechState.Invalid):
    self.expectedDuration_ms = expectedDuration_ms
    self.ttsID = ttsID
    self.ttsState = ttsState

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

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

  def pack_to(self, writer):
    "Writes the current TextToSpeechEvent to the given BinaryWriter."
    writer.write(self._expectedDuration_ms, 'f')
    writer.write(self._ttsID, 'B')
    writer.write(self._ttsState, 'B')

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

  def __str__(self):
    return '{type}(expectedDuration_ms={expectedDuration_ms}, ttsID={ttsID}, ttsState={ttsState})'.format(
      type=type(self).__name__,
      expectedDuration_ms=self._expectedDuration_ms,
      ttsID=self._ttsID,
      ttsState=self._ttsState)

  def __repr__(self):
    return '{type}(expectedDuration_ms={expectedDuration_ms}, ttsID={ttsID}, ttsState={ttsState})'.format(
      type=type(self).__name__,
      expectedDuration_ms=repr(self._expectedDuration_ms),
      ttsID=repr(self._ttsID),
      ttsState=repr(self._ttsState))

Anki.Vector.TextToSpeechEvent = TextToSpeechEvent
del TextToSpeechEvent


class StreamCameraImages(object):
  "Generated message-passing message."

  __slots__ = (
    '_enable', # bool
  )

  @property
  def enable(self):
    "bool enable struct property."
    return self._enable

  @enable.setter
  def enable(self, value):
    self._enable = msgbuffers.validate_bool(
      'StreamCameraImages.enable', value)

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

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

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

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

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

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

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

Anki.Vector.StreamCameraImages = StreamCameraImages
del StreamCameraImages


class DebugScreenMode(object):
  "Generated message-passing message."

  __slots__ = (
    '_isDebug',   # bool
    '_needsWait', # bool
    '_fromMute',  # bool
  )

  @property
  def isDebug(self):
    "bool isDebug struct property."
    return self._isDebug

  @isDebug.setter
  def isDebug(self, value):
    self._isDebug = msgbuffers.validate_bool(
      'DebugScreenMode.isDebug', value)

  @property
  def needsWait(self):
    "bool needsWait struct property."
    return self._needsWait

  @needsWait.setter
  def needsWait(self, value):
    self._needsWait = msgbuffers.validate_bool(
      'DebugScreenMode.needsWait', value)

  @property
  def fromMute(self):
    "bool fromMute struct property."
    return self._fromMute

  @fromMute.setter
  def fromMute(self, value):
    self._fromMute = msgbuffers.validate_bool(
      'DebugScreenMode.fromMute', value)

  def __init__(self, isDebug=False, needsWait=False, fromMute=False):
    self.isDebug = isDebug
    self.needsWait = needsWait
    self.fromMute = fromMute

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

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

  def pack_to(self, writer):
    "Writes the current DebugScreenMode to the given BinaryWriter."
    writer.write(int(self._isDebug), 'b')
    writer.write(int(self._needsWait), 'b')
    writer.write(int(self._fromMute), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._isDebug == other._isDebug and
        self._needsWait == other._needsWait and
        self._fromMute == other._fromMute)
    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._isDebug, 'b') +
      msgbuffers.size(self._needsWait, 'b') +
      msgbuffers.size(self._fromMute, 'b'))

  def __str__(self):
    return '{type}(isDebug={isDebug}, needsWait={needsWait}, fromMute={fromMute})'.format(
      type=type(self).__name__,
      isDebug=self._isDebug,
      needsWait=self._needsWait,
      fromMute=self._fromMute)

  def __repr__(self):
    return '{type}(isDebug={isDebug}, needsWait={needsWait}, fromMute={fromMute})'.format(
      type=type(self).__name__,
      isDebug=repr(self._isDebug),
      needsWait=repr(self._needsWait),
      fromMute=repr(self._fromMute))

Anki.Vector.DebugScreenMode = DebugScreenMode
del DebugScreenMode


class RobotAvailable(object):
  "Generated message-passing message."

  __slots__ = ()

  def __init__(self):
    pass

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

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

  def pack_to(self, writer):
    "Writes the current RobotAvailable to the given BinaryWriter."

  def __eq__(self, other):
    if type(self) is type(other):
      return True
    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 0

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

  def __repr__(self):
    return '{type}()'.format(type=type(self).__name__)

Anki.Vector.RobotAvailable = RobotAvailable
del RobotAvailable


class AudioStreamStatusEvent(object):
  "Generated message-passing message."

  __slots__ = (
    '_audioReceived',  # uint_32
    '_audioPlayed',    # uint_32
    '_streamResultID', # Anki.Vector.SDKAudioStreamingState
  )

  @property
  def audioReceived(self):
    "uint_32 audioReceived struct property."
    return self._audioReceived

  @audioReceived.setter
  def audioReceived(self, value):
    self._audioReceived = msgbuffers.validate_integer(
      'AudioStreamStatusEvent.audioReceived', value, 0, 4294967295)

  @property
  def audioPlayed(self):
    "uint_32 audioPlayed struct property."
    return self._audioPlayed

  @audioPlayed.setter
  def audioPlayed(self, value):
    self._audioPlayed = msgbuffers.validate_integer(
      'AudioStreamStatusEvent.audioPlayed', value, 0, 4294967295)

  @property
  def streamResultID(self):
    "Anki.Vector.SDKAudioStreamingState streamResultID struct property."
    return self._streamResultID

  @streamResultID.setter
  def streamResultID(self, value):
    self._streamResultID = msgbuffers.validate_integer(
      'AudioStreamStatusEvent.streamResultID', value, 0, 255)

  def __init__(self, audioReceived=0, audioPlayed=0, streamResultID=Anki.Vector.SDKAudioStreamingState.Invalid):
    self.audioReceived = audioReceived
    self.audioPlayed = audioPlayed
    self.streamResultID = streamResultID

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

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

  def pack_to(self, writer):
    "Writes the current AudioStreamStatusEvent to the given BinaryWriter."
    writer.write(self._audioReceived, 'I')
    writer.write(self._audioPlayed, 'I')
    writer.write(self._streamResultID, 'B')

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

  def __str__(self):
    return '{type}(audioReceived={audioReceived}, audioPlayed={audioPlayed}, streamResultID={streamResultID})'.format(
      type=type(self).__name__,
      audioReceived=self._audioReceived,
      audioPlayed=self._audioPlayed,
      streamResultID=self._streamResultID)

  def __repr__(self):
    return '{type}(audioReceived={audioReceived}, audioPlayed={audioPlayed}, streamResultID={streamResultID})'.format(
      type=type(self).__name__,
      audioReceived=repr(self._audioReceived),
      audioPlayed=repr(self._audioPlayed),
      streamResultID=repr(self._streamResultID))

Anki.Vector.AudioStreamStatusEvent = AudioStreamStatusEvent
del AudioStreamStatusEvent