"""
Autogenerated python message buffer code.
Source: clad/types/dockingSignals.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/types/dockingSignals.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.RobotInterface = msgbuffers.Namespace()

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

class DockingMethod(object):
  "Automatically-generated uint_8 enumeration."
  BLIND_DOCKING          = 0
  TRACKER_DOCKING        = 1
  HYBRID_DOCKING         = 2
  HYBRID_DOCKING_BEELINE = 3
  EVEN_BLINDER_DOCKING   = 4

Anki.Vector.DockingMethod = DockingMethod
del DockingMethod


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

  __slots__ = (
    '_horizontalOffset_mm',    # float_32
    '_speed_mmps',             # float_32
    '_accel_mmps2',            # float_32
    '_decel_mmps2',            # float_32
    '_action',                 # Anki.Vector.DockAction
    '_numRetries',             # uint_8
    '_dockingMethod',          # Anki.Vector.DockingMethod
    '_doLiftLoadCheck',        # bool
    '_backUpWhileLiftingCube', # bool
  )

  @property
  def horizontalOffset_mm(self):
    "float_32 horizontalOffset_mm struct property."
    return self._horizontalOffset_mm

  @horizontalOffset_mm.setter
  def horizontalOffset_mm(self, value):
    self._horizontalOffset_mm = msgbuffers.validate_float(
      'DockWithObject.horizontalOffset_mm', value, 'f')

  @property
  def speed_mmps(self):
    "float_32 speed_mmps struct property."
    return self._speed_mmps

  @speed_mmps.setter
  def speed_mmps(self, value):
    self._speed_mmps = msgbuffers.validate_float(
      'DockWithObject.speed_mmps', value, 'f')

  @property
  def accel_mmps2(self):
    "float_32 accel_mmps2 struct property."
    return self._accel_mmps2

  @accel_mmps2.setter
  def accel_mmps2(self, value):
    self._accel_mmps2 = msgbuffers.validate_float(
      'DockWithObject.accel_mmps2', value, 'f')

  @property
  def decel_mmps2(self):
    "float_32 decel_mmps2 struct property."
    return self._decel_mmps2

  @decel_mmps2.setter
  def decel_mmps2(self, value):
    self._decel_mmps2 = msgbuffers.validate_float(
      'DockWithObject.decel_mmps2', value, 'f')

  @property
  def action(self):
    "Anki.Vector.DockAction action struct property."
    return self._action

  @action.setter
  def action(self, value):
    self._action = msgbuffers.validate_integer(
      'DockWithObject.action', value, 0, 255)

  @property
  def numRetries(self):
    "uint_8 numRetries struct property."
    return self._numRetries

  @numRetries.setter
  def numRetries(self, value):
    self._numRetries = msgbuffers.validate_integer(
      'DockWithObject.numRetries', value, 0, 255)

  @property
  def dockingMethod(self):
    "Anki.Vector.DockingMethod dockingMethod struct property."
    return self._dockingMethod

  @dockingMethod.setter
  def dockingMethod(self, value):
    self._dockingMethod = msgbuffers.validate_integer(
      'DockWithObject.dockingMethod', value, 0, 255)

  @property
  def doLiftLoadCheck(self):
    "bool doLiftLoadCheck struct property."
    return self._doLiftLoadCheck

  @doLiftLoadCheck.setter
  def doLiftLoadCheck(self, value):
    self._doLiftLoadCheck = msgbuffers.validate_bool(
      'DockWithObject.doLiftLoadCheck', value)

  @property
  def backUpWhileLiftingCube(self):
    "bool backUpWhileLiftingCube struct property."
    return self._backUpWhileLiftingCube

  @backUpWhileLiftingCube.setter
  def backUpWhileLiftingCube(self, value):
    self._backUpWhileLiftingCube = msgbuffers.validate_bool(
      'DockWithObject.backUpWhileLiftingCube', value)

  def __init__(self, horizontalOffset_mm=0.0, speed_mmps=0.0, accel_mmps2=0.0, decel_mmps2=0.0, action=Anki.Vector.DockAction.DA_PICKUP_LOW, numRetries=0, dockingMethod=Anki.Vector.DockingMethod.BLIND_DOCKING, doLiftLoadCheck=False, backUpWhileLiftingCube=False):
    self.horizontalOffset_mm = horizontalOffset_mm
    self.speed_mmps = speed_mmps
    self.accel_mmps2 = accel_mmps2
    self.decel_mmps2 = decel_mmps2
    self.action = action
    self.numRetries = numRetries
    self.dockingMethod = dockingMethod
    self.doLiftLoadCheck = doLiftLoadCheck
    self.backUpWhileLiftingCube = backUpWhileLiftingCube

  @classmethod
  def unpack(cls, buffer):
    "Reads a new DockWithObject from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('DockWithObject.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 DockWithObject from the given BinaryReader."
    _horizontalOffset_mm = reader.read('f')
    _speed_mmps = reader.read('f')
    _accel_mmps2 = reader.read('f')
    _decel_mmps2 = reader.read('f')
    _action = reader.read('B')
    _numRetries = reader.read('B')
    _dockingMethod = reader.read('B')
    _doLiftLoadCheck = bool(reader.read('b'))
    _backUpWhileLiftingCube = bool(reader.read('b'))
    return cls(_horizontalOffset_mm, _speed_mmps, _accel_mmps2, _decel_mmps2, _action, _numRetries, _dockingMethod, _doLiftLoadCheck, _backUpWhileLiftingCube)

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

  def pack_to(self, writer):
    "Writes the current DockWithObject to the given BinaryWriter."
    writer.write(self._horizontalOffset_mm, 'f')
    writer.write(self._speed_mmps, 'f')
    writer.write(self._accel_mmps2, 'f')
    writer.write(self._decel_mmps2, 'f')
    writer.write(self._action, 'B')
    writer.write(self._numRetries, 'B')
    writer.write(self._dockingMethod, 'B')
    writer.write(int(self._doLiftLoadCheck), 'b')
    writer.write(int(self._backUpWhileLiftingCube), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._horizontalOffset_mm == other._horizontalOffset_mm and
        self._speed_mmps == other._speed_mmps and
        self._accel_mmps2 == other._accel_mmps2 and
        self._decel_mmps2 == other._decel_mmps2 and
        self._action == other._action and
        self._numRetries == other._numRetries and
        self._dockingMethod == other._dockingMethod and
        self._doLiftLoadCheck == other._doLiftLoadCheck and
        self._backUpWhileLiftingCube == other._backUpWhileLiftingCube)
    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._horizontalOffset_mm, 'f') +
      msgbuffers.size(self._speed_mmps, 'f') +
      msgbuffers.size(self._accel_mmps2, 'f') +
      msgbuffers.size(self._decel_mmps2, 'f') +
      msgbuffers.size(self._action, 'B') +
      msgbuffers.size(self._numRetries, 'B') +
      msgbuffers.size(self._dockingMethod, 'B') +
      msgbuffers.size(self._doLiftLoadCheck, 'b') +
      msgbuffers.size(self._backUpWhileLiftingCube, 'b'))

  def __str__(self):
    return '{type}(horizontalOffset_mm={horizontalOffset_mm}, speed_mmps={speed_mmps}, accel_mmps2={accel_mmps2}, decel_mmps2={decel_mmps2}, action={action}, numRetries={numRetries}, dockingMethod={dockingMethod}, doLiftLoadCheck={doLiftLoadCheck}, backUpWhileLiftingCube={backUpWhileLiftingCube})'.format(
      type=type(self).__name__,
      horizontalOffset_mm=self._horizontalOffset_mm,
      speed_mmps=self._speed_mmps,
      accel_mmps2=self._accel_mmps2,
      decel_mmps2=self._decel_mmps2,
      action=self._action,
      numRetries=self._numRetries,
      dockingMethod=self._dockingMethod,
      doLiftLoadCheck=self._doLiftLoadCheck,
      backUpWhileLiftingCube=self._backUpWhileLiftingCube)

  def __repr__(self):
    return '{type}(horizontalOffset_mm={horizontalOffset_mm}, speed_mmps={speed_mmps}, accel_mmps2={accel_mmps2}, decel_mmps2={decel_mmps2}, action={action}, numRetries={numRetries}, dockingMethod={dockingMethod}, doLiftLoadCheck={doLiftLoadCheck}, backUpWhileLiftingCube={backUpWhileLiftingCube})'.format(
      type=type(self).__name__,
      horizontalOffset_mm=repr(self._horizontalOffset_mm),
      speed_mmps=repr(self._speed_mmps),
      accel_mmps2=repr(self._accel_mmps2),
      decel_mmps2=repr(self._decel_mmps2),
      action=repr(self._action),
      numRetries=repr(self._numRetries),
      dockingMethod=repr(self._dockingMethod),
      doLiftLoadCheck=repr(self._doLiftLoadCheck),
      backUpWhileLiftingCube=repr(self._backUpWhileLiftingCube))

Anki.Vector.DockWithObject = DockWithObject
del DockWithObject


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

  __slots__ = ()

  def __init__(self):
    pass

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

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

  def pack_to(self, writer):
    "Writes the current AbortDocking 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.AbortDocking = AbortDocking
del AbortDocking


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

  __slots__ = (
    '_rel_x_mm',    # float_32
    '_rel_y_mm',    # float_32
    '_rel_angle',   # float_32
    '_speed_mmps',  # float_32
    '_accel_mmps2', # float_32
    '_decel_mmps2', # float_32
  )

  @property
  def rel_x_mm(self):
    "float_32 rel_x_mm struct property."
    return self._rel_x_mm

  @rel_x_mm.setter
  def rel_x_mm(self, value):
    self._rel_x_mm = msgbuffers.validate_float(
      'PlaceObjectOnGround.rel_x_mm', value, 'f')

  @property
  def rel_y_mm(self):
    "float_32 rel_y_mm struct property."
    return self._rel_y_mm

  @rel_y_mm.setter
  def rel_y_mm(self, value):
    self._rel_y_mm = msgbuffers.validate_float(
      'PlaceObjectOnGround.rel_y_mm', value, 'f')

  @property
  def rel_angle(self):
    "float_32 rel_angle struct property."
    return self._rel_angle

  @rel_angle.setter
  def rel_angle(self, value):
    self._rel_angle = msgbuffers.validate_float(
      'PlaceObjectOnGround.rel_angle', value, 'f')

  @property
  def speed_mmps(self):
    "float_32 speed_mmps struct property."
    return self._speed_mmps

  @speed_mmps.setter
  def speed_mmps(self, value):
    self._speed_mmps = msgbuffers.validate_float(
      'PlaceObjectOnGround.speed_mmps', value, 'f')

  @property
  def accel_mmps2(self):
    "float_32 accel_mmps2 struct property."
    return self._accel_mmps2

  @accel_mmps2.setter
  def accel_mmps2(self, value):
    self._accel_mmps2 = msgbuffers.validate_float(
      'PlaceObjectOnGround.accel_mmps2', value, 'f')

  @property
  def decel_mmps2(self):
    "float_32 decel_mmps2 struct property."
    return self._decel_mmps2

  @decel_mmps2.setter
  def decel_mmps2(self, value):
    self._decel_mmps2 = msgbuffers.validate_float(
      'PlaceObjectOnGround.decel_mmps2', value, 'f')

  def __init__(self, rel_x_mm=0.0, rel_y_mm=0.0, rel_angle=0.0, speed_mmps=0.0, accel_mmps2=0.0, decel_mmps2=0.0):
    self.rel_x_mm = rel_x_mm
    self.rel_y_mm = rel_y_mm
    self.rel_angle = rel_angle
    self.speed_mmps = speed_mmps
    self.accel_mmps2 = accel_mmps2
    self.decel_mmps2 = decel_mmps2

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

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

  def pack_to(self, writer):
    "Writes the current PlaceObjectOnGround to the given BinaryWriter."
    writer.write(self._rel_x_mm, 'f')
    writer.write(self._rel_y_mm, 'f')
    writer.write(self._rel_angle, 'f')
    writer.write(self._speed_mmps, 'f')
    writer.write(self._accel_mmps2, 'f')
    writer.write(self._decel_mmps2, 'f')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._rel_x_mm == other._rel_x_mm and
        self._rel_y_mm == other._rel_y_mm and
        self._rel_angle == other._rel_angle and
        self._speed_mmps == other._speed_mmps and
        self._accel_mmps2 == other._accel_mmps2 and
        self._decel_mmps2 == other._decel_mmps2)
    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._rel_x_mm, 'f') +
      msgbuffers.size(self._rel_y_mm, 'f') +
      msgbuffers.size(self._rel_angle, 'f') +
      msgbuffers.size(self._speed_mmps, 'f') +
      msgbuffers.size(self._accel_mmps2, 'f') +
      msgbuffers.size(self._decel_mmps2, 'f'))

  def __str__(self):
    return '{type}(rel_x_mm={rel_x_mm}, rel_y_mm={rel_y_mm}, rel_angle={rel_angle}, speed_mmps={speed_mmps}, accel_mmps2={accel_mmps2}, decel_mmps2={decel_mmps2})'.format(
      type=type(self).__name__,
      rel_x_mm=self._rel_x_mm,
      rel_y_mm=self._rel_y_mm,
      rel_angle=self._rel_angle,
      speed_mmps=self._speed_mmps,
      accel_mmps2=self._accel_mmps2,
      decel_mmps2=self._decel_mmps2)

  def __repr__(self):
    return '{type}(rel_x_mm={rel_x_mm}, rel_y_mm={rel_y_mm}, rel_angle={rel_angle}, speed_mmps={speed_mmps}, accel_mmps2={accel_mmps2}, decel_mmps2={decel_mmps2})'.format(
      type=type(self).__name__,
      rel_x_mm=repr(self._rel_x_mm),
      rel_y_mm=repr(self._rel_y_mm),
      rel_angle=repr(self._rel_angle),
      speed_mmps=repr(self._speed_mmps),
      accel_mmps2=repr(self._accel_mmps2),
      decel_mmps2=repr(self._decel_mmps2))

Anki.Vector.PlaceObjectOnGround = PlaceObjectOnGround
del PlaceObjectOnGround


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

  __slots__ = (
    '_timestamp',          # uint_32
    '_x_distErr',          # float_32
    '_y_horErr',           # float_32
    '_z_height',           # float_32
    '_angleErr',           # float_32
    '_didTrackingSucceed', # bool
    '_isApproximate',      # bool
  )

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

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

  @property
  def x_distErr(self):
    "float_32 x_distErr struct property."
    return self._x_distErr

  @x_distErr.setter
  def x_distErr(self, value):
    self._x_distErr = msgbuffers.validate_float(
      'DockingErrorSignal.x_distErr', value, 'f')

  @property
  def y_horErr(self):
    "float_32 y_horErr struct property."
    return self._y_horErr

  @y_horErr.setter
  def y_horErr(self, value):
    self._y_horErr = msgbuffers.validate_float(
      'DockingErrorSignal.y_horErr', value, 'f')

  @property
  def z_height(self):
    "float_32 z_height struct property."
    return self._z_height

  @z_height.setter
  def z_height(self, value):
    self._z_height = msgbuffers.validate_float(
      'DockingErrorSignal.z_height', value, 'f')

  @property
  def angleErr(self):
    "float_32 angleErr struct property."
    return self._angleErr

  @angleErr.setter
  def angleErr(self, value):
    self._angleErr = msgbuffers.validate_float(
      'DockingErrorSignal.angleErr', value, 'f')

  @property
  def didTrackingSucceed(self):
    "bool didTrackingSucceed struct property."
    return self._didTrackingSucceed

  @didTrackingSucceed.setter
  def didTrackingSucceed(self, value):
    self._didTrackingSucceed = msgbuffers.validate_bool(
      'DockingErrorSignal.didTrackingSucceed', value)

  @property
  def isApproximate(self):
    "bool isApproximate struct property."
    return self._isApproximate

  @isApproximate.setter
  def isApproximate(self, value):
    self._isApproximate = msgbuffers.validate_bool(
      'DockingErrorSignal.isApproximate', value)

  def __init__(self, timestamp=0, x_distErr=0.0, y_horErr=0.0, z_height=0.0, angleErr=0.0, didTrackingSucceed=False, isApproximate=False):
    self.timestamp = timestamp
    self.x_distErr = x_distErr
    self.y_horErr = y_horErr
    self.z_height = z_height
    self.angleErr = angleErr
    self.didTrackingSucceed = didTrackingSucceed
    self.isApproximate = isApproximate

  @classmethod
  def unpack(cls, buffer):
    "Reads a new DockingErrorSignal from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('DockingErrorSignal.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 DockingErrorSignal from the given BinaryReader."
    _timestamp = reader.read('I')
    _x_distErr = reader.read('f')
    _y_horErr = reader.read('f')
    _z_height = reader.read('f')
    _angleErr = reader.read('f')
    _didTrackingSucceed = bool(reader.read('b'))
    _isApproximate = bool(reader.read('b'))
    return cls(_timestamp, _x_distErr, _y_horErr, _z_height, _angleErr, _didTrackingSucceed, _isApproximate)

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

  def pack_to(self, writer):
    "Writes the current DockingErrorSignal to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(self._x_distErr, 'f')
    writer.write(self._y_horErr, 'f')
    writer.write(self._z_height, 'f')
    writer.write(self._angleErr, 'f')
    writer.write(int(self._didTrackingSucceed), 'b')
    writer.write(int(self._isApproximate), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._timestamp == other._timestamp and
        self._x_distErr == other._x_distErr and
        self._y_horErr == other._y_horErr and
        self._z_height == other._z_height and
        self._angleErr == other._angleErr and
        self._didTrackingSucceed == other._didTrackingSucceed and
        self._isApproximate == other._isApproximate)
    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._x_distErr, 'f') +
      msgbuffers.size(self._y_horErr, 'f') +
      msgbuffers.size(self._z_height, 'f') +
      msgbuffers.size(self._angleErr, 'f') +
      msgbuffers.size(self._didTrackingSucceed, 'b') +
      msgbuffers.size(self._isApproximate, 'b'))

  def __str__(self):
    return '{type}(timestamp={timestamp}, x_distErr={x_distErr}, y_horErr={y_horErr}, z_height={z_height}, angleErr={angleErr}, didTrackingSucceed={didTrackingSucceed}, isApproximate={isApproximate})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      x_distErr=self._x_distErr,
      y_horErr=self._y_horErr,
      z_height=self._z_height,
      angleErr=self._angleErr,
      didTrackingSucceed=self._didTrackingSucceed,
      isApproximate=self._isApproximate)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, x_distErr={x_distErr}, y_horErr={y_horErr}, z_height={z_height}, angleErr={angleErr}, didTrackingSucceed={didTrackingSucceed}, isApproximate={isApproximate})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      x_distErr=repr(self._x_distErr),
      y_horErr=repr(self._y_horErr),
      z_height=repr(self._z_height),
      angleErr=repr(self._angleErr),
      didTrackingSucceed=repr(self._didTrackingSucceed),
      isApproximate=repr(self._isApproximate))

Anki.Vector.DockingErrorSignal = DockingErrorSignal
del DockingErrorSignal


class DockingResult(object):
  "Automatically-generated int_8 enumeration."
  DOCK_UNKNOWN                            = 0
  DOCK_INTERRUPTED                        = 1
  DOCK_SUCCESS                            = 2
  DOCK_SUCCESS_RETRY                      = 3
  DOCK_SUCCESS_HANNS_MANEUVER             = 4
  DOCK_FAILURE                            = 5
  DOCK_FAILURE_TOO_LONG_WITHOUT_BLOCKPOSE = 6
  DOCK_FAILURE_TOO_HIGH                   = 7
  DOCK_FAILURE_RETRY                      = 8

Anki.Vector.DockingResult = DockingResult
del DockingResult


class Status(object):
  "Automatically-generated int_8 enumeration."
  STATUS_BACKING_UP           = 0
  STATUS_DOING_HANNS_MANEUVER = 1

Anki.Vector.Status = Status
del Status


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

  __slots__ = (
    '_timestamp', # uint_32
    '_status',    # Anki.Vector.Status
  )

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

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

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

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_integer(
      'DockingStatus.status', value, -128, 127)

  def __init__(self, timestamp=0, status=Anki.Vector.Status.STATUS_BACKING_UP):
    self.timestamp = timestamp
    self.status = status

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

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

  def pack_to(self, writer):
    "Writes the current DockingStatus to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(self._status, 'b')

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

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

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

Anki.Vector.DockingStatus = DockingStatus
del DockingStatus


class BlockStatus(object):
  "Automatically-generated int_8 enumeration."
  NO_BLOCK        = 0
  BLOCK_PLACED    = 1
  BLOCK_PICKED_UP = 2

Anki.Vector.BlockStatus = BlockStatus
del BlockStatus


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

  __slots__ = (
    '_timestamp',   # uint_32
    '_didSucceed',  # bool
    '_result',      # Anki.Vector.DockingResult
    '_blockStatus', # Anki.Vector.BlockStatus
  )

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

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

  @property
  def didSucceed(self):
    "bool didSucceed struct property."
    return self._didSucceed

  @didSucceed.setter
  def didSucceed(self, value):
    self._didSucceed = msgbuffers.validate_bool(
      'PickAndPlaceResult.didSucceed', value)

  @property
  def result(self):
    "Anki.Vector.DockingResult result struct property."
    return self._result

  @result.setter
  def result(self, value):
    self._result = msgbuffers.validate_integer(
      'PickAndPlaceResult.result', value, -128, 127)

  @property
  def blockStatus(self):
    "Anki.Vector.BlockStatus blockStatus struct property."
    return self._blockStatus

  @blockStatus.setter
  def blockStatus(self, value):
    self._blockStatus = msgbuffers.validate_integer(
      'PickAndPlaceResult.blockStatus', value, -128, 127)

  def __init__(self, timestamp=0, didSucceed=False, result=Anki.Vector.DockingResult.DOCK_UNKNOWN, blockStatus=Anki.Vector.BlockStatus.NO_BLOCK):
    self.timestamp = timestamp
    self.didSucceed = didSucceed
    self.result = result
    self.blockStatus = blockStatus

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

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

  def pack_to(self, writer):
    "Writes the current PickAndPlaceResult to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(int(self._didSucceed), 'b')
    writer.write(self._result, 'b')
    writer.write(self._blockStatus, 'b')

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

  def __str__(self):
    return '{type}(timestamp={timestamp}, didSucceed={didSucceed}, result={result}, blockStatus={blockStatus})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      didSucceed=self._didSucceed,
      result=self._result,
      blockStatus=self._blockStatus)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, didSucceed={didSucceed}, result={result}, blockStatus={blockStatus})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      didSucceed=repr(self._didSucceed),
      result=repr(self._result),
      blockStatus=repr(self._blockStatus))

Anki.Vector.PickAndPlaceResult = PickAndPlaceResult
del PickAndPlaceResult


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

  __slots__ = (
    '_action', # Anki.Vector.DockAction
  )

  @property
  def action(self):
    "Anki.Vector.DockAction action struct property."
    return self._action

  @action.setter
  def action(self, value):
    self._action = msgbuffers.validate_integer(
      'MovingLiftPostDock.action', value, 0, 255)

  def __init__(self, action=Anki.Vector.DockAction.DA_PICKUP_LOW):
    self.action = action

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

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

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

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

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

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

Anki.Vector.MovingLiftPostDock = MovingLiftPostDock
del MovingLiftPostDock


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

  __slots__ = (
    '_timestamp',  # uint_32
    '_didSucceed', # bool
  )

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

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

  @property
  def didSucceed(self):
    "bool didSucceed struct property."
    return self._didSucceed

  @didSucceed.setter
  def didSucceed(self, value):
    self._didSucceed = msgbuffers.validate_bool(
      'ChargerMountComplete.didSucceed', value)

  def __init__(self, timestamp=0, didSucceed=False):
    self.timestamp = timestamp
    self.didSucceed = didSucceed

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

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

  def pack_to(self, writer):
    "Writes the current ChargerMountComplete to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(int(self._didSucceed), 'b')

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

  def __str__(self):
    return '{type}(timestamp={timestamp}, didSucceed={didSucceed})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      didSucceed=self._didSucceed)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, didSucceed={didSucceed})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      didSucceed=repr(self._didSucceed))

Anki.Vector.ChargerMountComplete = ChargerMountComplete
del ChargerMountComplete


class CliffAlignResult(object):
  "Automatically-generated int_8 enumeration."
  CLIFF_ALIGN_SUCCESS              = 0
  CLIFF_ALIGN_FAILURE_TIMEOUT      = 1
  CLIFF_ALIGN_FAILURE_NO_TURNING   = 2
  CLIFF_ALIGN_FAILURE_OVER_TURNING = 3
  CLIFF_ALIGN_FAILURE_NO_WHITE     = 4
  CLIFF_ALIGN_FAILURE_STOPPED      = 5

Anki.Vector.CliffAlignResult = CliffAlignResult
del CliffAlignResult


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

  __slots__ = (
    '_timestamp', # uint_32
    '_result',    # Anki.Vector.CliffAlignResult
  )

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

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

  @property
  def result(self):
    "Anki.Vector.CliffAlignResult result struct property."
    return self._result

  @result.setter
  def result(self, value):
    self._result = msgbuffers.validate_integer(
      'CliffAlignComplete.result', value, -128, 127)

  def __init__(self, timestamp=0, result=Anki.Vector.CliffAlignResult.CLIFF_ALIGN_SUCCESS):
    self.timestamp = timestamp
    self.result = result

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

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

  def pack_to(self, writer):
    "Writes the current CliffAlignComplete to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(self._result, 'b')

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

  def __str__(self):
    return '{type}(timestamp={timestamp}, result={result})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      result=self._result)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, result={result})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      result=repr(self._result))

Anki.Vector.CliffAlignComplete = CliffAlignComplete
del CliffAlignComplete


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

  __slots__ = (
    '_pose',                  # Anki.Vector.RobotPose
    '_followingMarkerNormal', # bool
  )

  @property
  def pose(self):
    "Anki.Vector.RobotPose pose struct property."
    return self._pose

  @pose.setter
  def pose(self, value):
    self._pose = msgbuffers.validate_object(
      'GoalPose.pose', value, Anki.Vector.RobotPose)

  @property
  def followingMarkerNormal(self):
    "bool followingMarkerNormal struct property."
    return self._followingMarkerNormal

  @followingMarkerNormal.setter
  def followingMarkerNormal(self, value):
    self._followingMarkerNormal = msgbuffers.validate_bool(
      'GoalPose.followingMarkerNormal', value)

  def __init__(self, pose=Anki.Vector.RobotPose(), followingMarkerNormal=False):
    self.pose = pose
    self.followingMarkerNormal = followingMarkerNormal

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

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

  def pack_to(self, writer):
    "Writes the current GoalPose to the given BinaryWriter."
    writer.write_object(self._pose)
    writer.write(int(self._followingMarkerNormal), 'b')

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

  def __str__(self):
    return '{type}(pose={pose}, followingMarkerNormal={followingMarkerNormal})'.format(
      type=type(self).__name__,
      pose=self._pose,
      followingMarkerNormal=self._followingMarkerNormal)

  def __repr__(self):
    return '{type}(pose={pose}, followingMarkerNormal={followingMarkerNormal})'.format(
      type=type(self).__name__,
      pose=repr(self._pose),
      followingMarkerNormal=repr(self._followingMarkerNormal))

Anki.Vector.GoalPose = GoalPose
del GoalPose