// Autogenerated Go message buffer code.
// Source: clad/gateway/messageRobotToExternal.clad
// Full command line: victor-clad/tools/message-buffers/emitters/Go_emitter.py -C src -o generated/cladgo/src clad/gateway/messageRobotToExternal.clad

package gateway

import (
  "bytes"
  "encoding/binary"
  "errors"
  "anki/clad"
  "fmt"
)

// MESSAGE UiDeviceConnected
type UiDeviceConnected struct {
  Placeholder string
}

func (u *UiDeviceConnected) Size() uint32 {
  var result uint32
  result += 1 // Placeholder length (uint_8)
  result += uint32(len(u.Placeholder)) // uint_8 array
  return result
}

func (u *UiDeviceConnected) Unpack(buf *bytes.Buffer) error {
  var PlaceholderLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &PlaceholderLen); err != nil {
    return err
  }
  u.Placeholder = string(buf.Next(int(PlaceholderLen)))
  if len(u.Placeholder) != int(PlaceholderLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (u *UiDeviceConnected) Pack(buf *bytes.Buffer) error {
  if len(u.Placeholder) > 255 {
    return errors.New("max_length overflow in field Placeholder")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(u.Placeholder))); err != nil {
    return err
  }
  if _, err := buf.WriteString(u.Placeholder); err != nil {
    return err
  }
  return nil
}

func (u *UiDeviceConnected) String() string {
  return fmt.Sprint("Placeholder: {", u.Placeholder, "}")
}


// STRUCTURE AnimationCompleted
type AnimationCompleted struct {
  AnimationName string
}

func (a *AnimationCompleted) Size() uint32 {
  var result uint32
  result += 1 // AnimationName length (uint_8)
  result += uint32(len(a.AnimationName)) // uint_8 array
  return result
}

func (a *AnimationCompleted) Unpack(buf *bytes.Buffer) error {
  var AnimationNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &AnimationNameLen); err != nil {
    return err
  }
  a.AnimationName = string(buf.Next(int(AnimationNameLen)))
  if len(a.AnimationName) != int(AnimationNameLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (a *AnimationCompleted) Pack(buf *bytes.Buffer) error {
  if len(a.AnimationName) > 255 {
    return errors.New("max_length overflow in field AnimationName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.AnimationName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.AnimationName); err != nil {
    return err
  }
  return nil
}

func (a *AnimationCompleted) String() string {
  return fmt.Sprint("AnimationName: {", a.AnimationName, "}")
}


// UNION ActionCompletedUnion
type ActionCompletedUnionTag uint8

const (
  ActionCompletedUnionTag_AnimationCompleted ActionCompletedUnionTag = 0x1 // 1
  ActionCompletedUnionTag_INVALID            ActionCompletedUnionTag = 255
)

type ActionCompletedUnion struct {
  tag *ActionCompletedUnionTag
  value clad.Struct
}

func (m *ActionCompletedUnion) Tag() ActionCompletedUnionTag {
  if m.tag == nil {
    return ActionCompletedUnionTag_INVALID
  }
  return *m.tag
}

func (m *ActionCompletedUnion) Size() uint32 {
  if m.tag == nil || *m.tag == ActionCompletedUnionTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *ActionCompletedUnion) Pack(buf *bytes.Buffer) error {
  tag := ActionCompletedUnionTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == ActionCompletedUnionTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *ActionCompletedUnion) unpackStruct(tag ActionCompletedUnionTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case ActionCompletedUnionTag_AnimationCompleted:
    var ret AnimationCompleted
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *ActionCompletedUnion) Unpack(buf *bytes.Buffer) error {
  tag := ActionCompletedUnionTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == ActionCompletedUnionTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = ActionCompletedUnionTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t ActionCompletedUnionTag) String() string {
  switch t {
  case ActionCompletedUnionTag_AnimationCompleted:
    return "AnimationCompleted"
  default:
    return "INVALID"
  }
}

func (m *ActionCompletedUnion) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == ActionCompletedUnionTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *ActionCompletedUnion) GetAnimationCompleted() *AnimationCompleted {
  if m.tag == nil || *m.tag != ActionCompletedUnionTag_AnimationCompleted {
    return nil
  }
  return m.value.(*AnimationCompleted)
}

func (m *ActionCompletedUnion) SetAnimationCompleted(value *AnimationCompleted) {
  newTag := ActionCompletedUnionTag_AnimationCompleted
  m.tag = &newTag
  m.value = value
}

func NewActionCompletedUnionWithAnimationCompleted(value *AnimationCompleted) *ActionCompletedUnion {
  var ret ActionCompletedUnion
  ret.SetAnimationCompleted(value)
  return &ret
}


// ENUM RobotActionType
type RobotActionType int32

const (
  RobotActionType_UNKNOWN RobotActionType = RobotActionType(-1)
)

// ENUM ActionResult
type ActionResult uint32

const (
  ActionResult_SUCCESS ActionResult = ActionResult(0)                       
  ActionResult_RUNNING ActionResult = ActionResult(16777216)                
  ActionResult_CANCELLED_WHILE_RUNNING ActionResult = ActionResult(33554432)
)

// ENUM ObjectFamily
type ObjectFamily int32

const (
  ObjectFamily_Invalid ObjectFamily = ObjectFamily(-1)    
  ObjectFamily_Unknown ObjectFamily = ObjectFamily(0)     
  ObjectFamily_Block ObjectFamily = ObjectFamily(1)       
  ObjectFamily_LightCube ObjectFamily = ObjectFamily(2)   
  ObjectFamily_Charger ObjectFamily = ObjectFamily(3)     
  ObjectFamily_CustomObject ObjectFamily = ObjectFamily(6)
)

// STRUCTURE ActiveAccel
type ActiveAccel struct {
  X float32
  Y float32
  Z float32
}

func (a *ActiveAccel) Size() uint32 {
  var result uint32
  result += 4 // X float_32
  result += 4 // Y float_32
  result += 4 // Z float_32
  return result
}

func (a *ActiveAccel) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &a.X); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.Y); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.Z); err != nil {
    return err
  }
  return nil
}

func (a *ActiveAccel) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, a.X); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.Y); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.Z); err != nil {
    return err
  }
  return nil
}

func (a *ActiveAccel) String() string {
  return fmt.Sprint("X: {", a.X, "} ",
    "Y: {", a.Y, "} ",
    "Z: {", a.Z, "}")
}


// ENUM UpAxis
type UpAxis uint8

const (
  UpAxis_XNegative UpAxis = iota
  UpAxis_XPositive              
  UpAxis_YNegative              
  UpAxis_YPositive              
  UpAxis_ZNegative              
  UpAxis_ZPositive              
  UpAxis_NumAxes                
  UpAxis_UnknownAxis            
)

// MESSAGE ObjectConnectionState
type ObjectConnectionState struct {
  ObjectID uint32
  FactoryID string
  ObjectType ObjectType
  Connected bool
}

func (o *ObjectConnectionState) Size() uint32 {
  var result uint32
  result += 4 // ObjectID uint_32
  result += 1 // FactoryID length (uint_8)
  result += uint32(len(o.FactoryID)) // uint_8 array
  result += 4 // ObjectType ObjectType
  result += 1 // Connected bool
  return result
}

func (o *ObjectConnectionState) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  var FactoryIDLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &FactoryIDLen); err != nil {
    return err
  }
  o.FactoryID = string(buf.Next(int(FactoryIDLen)))
  if len(o.FactoryID) != int(FactoryIDLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.Connected); err != nil {
    return err
  }
  return nil
}

func (o *ObjectConnectionState) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  if len(o.FactoryID) > 255 {
    return errors.New("max_length overflow in field FactoryID")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(o.FactoryID))); err != nil {
    return err
  }
  if _, err := buf.WriteString(o.FactoryID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.Connected); err != nil {
    return err
  }
  return nil
}

func (o *ObjectConnectionState) String() string {
  return fmt.Sprint("ObjectID: {", o.ObjectID, "} ",
    "FactoryID: {", o.FactoryID, "} ",
    "ObjectType: {", o.ObjectType, "} ",
    "Connected: {", o.Connected, "}")
}


// MESSAGE ObjectMoved
type ObjectMoved struct {
  Timestamp uint32
  ObjectID uint32
}

func (o *ObjectMoved) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectID uint_32
  return result
}

func (o *ObjectMoved) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectMoved) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectMoved) String() string {
  return fmt.Sprint("Timestamp: {", o.Timestamp, "} ",
    "ObjectID: {", o.ObjectID, "}")
}


// MESSAGE ObjectAvailable
type ObjectAvailable struct {
  FactoryId string
  ObjectType ObjectType
  Rssi int8
}

func (o *ObjectAvailable) Size() uint32 {
  var result uint32
  result += 1 // FactoryId length (uint_8)
  result += uint32(len(o.FactoryId)) // uint_8 array
  result += 4 // ObjectType ObjectType
  result += 1 // Rssi int_8
  return result
}

func (o *ObjectAvailable) Unpack(buf *bytes.Buffer) error {
  var FactoryIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &FactoryIdLen); err != nil {
    return err
  }
  o.FactoryId = string(buf.Next(int(FactoryIdLen)))
  if len(o.FactoryId) != int(FactoryIdLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.Rssi); err != nil {
    return err
  }
  return nil
}

func (o *ObjectAvailable) Pack(buf *bytes.Buffer) error {
  if len(o.FactoryId) > 255 {
    return errors.New("max_length overflow in field FactoryId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(o.FactoryId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(o.FactoryId); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.Rssi); err != nil {
    return err
  }
  return nil
}

func (o *ObjectAvailable) String() string {
  return fmt.Sprint("FactoryId: {", o.FactoryId, "} ",
    "ObjectType: {", o.ObjectType, "} ",
    "Rssi: {", o.Rssi, "}")
}


// MESSAGE ObjectStoppedMoving
type ObjectStoppedMoving struct {
  Timestamp uint32
  ObjectID uint32
}

func (o *ObjectStoppedMoving) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectID uint_32
  return result
}

func (o *ObjectStoppedMoving) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectStoppedMoving) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectStoppedMoving) String() string {
  return fmt.Sprint("Timestamp: {", o.Timestamp, "} ",
    "ObjectID: {", o.ObjectID, "}")
}


// MESSAGE ObjectUpAxisChanged
type ObjectUpAxisChanged struct {
  Timestamp uint32
  ObjectID uint32
  UpAxis UpAxis
}

func (o *ObjectUpAxisChanged) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectID uint_32
  result += 1 // UpAxis UpAxis
  return result
}

func (o *ObjectUpAxisChanged) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.UpAxis); err != nil {
    return err
  }
  return nil
}

func (o *ObjectUpAxisChanged) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.UpAxis); err != nil {
    return err
  }
  return nil
}

func (o *ObjectUpAxisChanged) String() string {
  return fmt.Sprint("Timestamp: {", o.Timestamp, "} ",
    "ObjectID: {", o.ObjectID, "} ",
    "UpAxis: {", o.UpAxis, "}")
}


// MESSAGE ObjectTapped
type ObjectTapped struct {
  Timestamp uint32
  ObjectID uint32
}

func (o *ObjectTapped) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectID uint_32
  return result
}

func (o *ObjectTapped) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectTapped) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  return nil
}

func (o *ObjectTapped) String() string {
  return fmt.Sprint("Timestamp: {", o.Timestamp, "} ",
    "ObjectID: {", o.ObjectID, "}")
}


// MESSAGE ObjectAccel
type ObjectAccel struct {
  Timestamp uint32
  ObjectID uint32
  Accel ActiveAccel
}

func (o *ObjectAccel) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectID uint_32
  result += o.Accel.Size()
  return result
}

func (o *ObjectAccel) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &o.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &o.ObjectID); err != nil {
    return err
  }
  if err := o.Accel.Unpack(buf); err != nil {
    return err
  }
  return nil
}

func (o *ObjectAccel) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, o.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, o.ObjectID); err != nil {
    return err
  }
  if err := o.Accel.Pack(buf); err != nil {
    return err
  }
  return nil
}

func (o *ObjectAccel) String() string {
  return fmt.Sprint("Timestamp: {", o.Timestamp, "} ",
    "ObjectID: {", o.ObjectID, "} ",
    "Accel: {", o.Accel, "}")
}


// MESSAGE RobotCompletedAction
type RobotCompletedAction struct {
  IdTag uint32
  ActionType RobotActionType
  Result ActionResult
  SubActionResults []ActionResult
  CompletionInfo ActionCompletedUnion
}

func (r *RobotCompletedAction) Size() uint32 {
  var result uint32
  result += 4 // IdTag uint_32
  result += 4 // ActionType RobotActionType
  result += 4 // Result ActionResult
  result += 1 // SubActionResults length (uint_8)
  result += uint32(len(r.SubActionResults)) * 4 // ActionResult array
  result += r.CompletionInfo.Size()
  return result
}

func (r *RobotCompletedAction) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &r.IdTag); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.ActionType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.Result); err != nil {
    return err
  }
  var SubActionResultsLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &SubActionResultsLen); err != nil {
    return err
  }
  r.SubActionResults = make([]ActionResult, SubActionResultsLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.SubActionResults); err != nil {
    return err
  }
  if err := r.CompletionInfo.Unpack(buf); err != nil {
    return err
  }
  return nil
}

func (r *RobotCompletedAction) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, r.IdTag); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.ActionType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.Result); err != nil {
    return err
  }
  if len(r.SubActionResults) > 255 {
    return errors.New("max_length overflow in field SubActionResults")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.SubActionResults))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.SubActionResults); err != nil {
    return err
  }
  if err := r.CompletionInfo.Pack(buf); err != nil {
    return err
  }
  return nil
}

func (r *RobotCompletedAction) String() string {
  return fmt.Sprint("IdTag: {", r.IdTag, "} ",
    "ActionType: {", r.ActionType, "} ",
    "Result: {", r.Result, "} ",
    "SubActionResults: {", r.SubActionResults, "} ",
    "CompletionInfo: {", r.CompletionInfo, "}")
}


// MESSAGE LoadedKnownFace
type LoadedKnownFace struct {
  SecondsSinceFirstEnrolled int64
  SecondsSinceLastUpdated int64
  SecondsSinceLastSeen int64
  LastSeenSecondsSinceEpoch int64
  FaceID int32
  Name string
}

func (l *LoadedKnownFace) Size() uint32 {
  var result uint32
  result += 8 // SecondsSinceFirstEnrolled int_64
  result += 8 // SecondsSinceLastUpdated int_64
  result += 8 // SecondsSinceLastSeen int_64
  result += 8 // LastSeenSecondsSinceEpoch int_64
  result += 4 // FaceID int_32
  result += 1 // Name length (uint_8)
  result += uint32(len(l.Name)) // uint_8 array
  return result
}

func (l *LoadedKnownFace) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &l.SecondsSinceFirstEnrolled); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &l.SecondsSinceLastUpdated); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &l.SecondsSinceLastSeen); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &l.LastSeenSecondsSinceEpoch); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &l.FaceID); err != nil {
    return err
  }
  var NameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &NameLen); err != nil {
    return err
  }
  l.Name = string(buf.Next(int(NameLen)))
  if len(l.Name) != int(NameLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (l *LoadedKnownFace) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, l.SecondsSinceFirstEnrolled); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, l.SecondsSinceLastUpdated); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, l.SecondsSinceLastSeen); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, l.LastSeenSecondsSinceEpoch); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, l.FaceID); err != nil {
    return err
  }
  if len(l.Name) > 255 {
    return errors.New("max_length overflow in field Name")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(l.Name))); err != nil {
    return err
  }
  if _, err := buf.WriteString(l.Name); err != nil {
    return err
  }
  return nil
}

func (l *LoadedKnownFace) String() string {
  return fmt.Sprint("SecondsSinceFirstEnrolled: {", l.SecondsSinceFirstEnrolled, "} ",
    "SecondsSinceLastUpdated: {", l.SecondsSinceLastUpdated, "} ",
    "SecondsSinceLastSeen: {", l.SecondsSinceLastSeen, "} ",
    "LastSeenSecondsSinceEpoch: {", l.LastSeenSecondsSinceEpoch, "} ",
    "FaceID: {", l.FaceID, "} ",
    "Name: {", l.Name, "}")
}


// MESSAGE EnrolledNamesResponse
type EnrolledNamesResponse struct {
  Faces []LoadedKnownFace
}

func (e *EnrolledNamesResponse) Size() uint32 {
  var result uint32
  result += 1 // Faces length (uint_8)
  for idx := range e.Faces {
    result += e.Faces[idx].Size()
  }
  return result
}

func (e *EnrolledNamesResponse) Unpack(buf *bytes.Buffer) error {
  var FacesLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &FacesLen); err != nil {
    return err
  }
  e.Faces = make([]LoadedKnownFace, FacesLen)
  for idx := range e.Faces {
    if err := e.Faces[idx].Unpack(buf); err != nil {
      return err
    }
  }
  return nil
}

func (e *EnrolledNamesResponse) Pack(buf *bytes.Buffer) error {
  if len(e.Faces) > 255 {
    return errors.New("max_length overflow in field Faces")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(e.Faces))); err != nil {
    return err
  }
  for idx := range e.Faces {
    if err := e.Faces[idx].Pack(buf); err != nil {
      return err
    }
  }
  return nil
}

func (e *EnrolledNamesResponse) String() string {
  return fmt.Sprint("Faces: {", e.Faces, "}")
}


// STRUCTURE AccelData
type AccelData struct {
  X float32
  Y float32
  Z float32
}

func (a *AccelData) Size() uint32 {
  var result uint32
  result += 4 // X float_32
  result += 4 // Y float_32
  result += 4 // Z float_32
  return result
}

func (a *AccelData) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &a.X); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.Y); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.Z); err != nil {
    return err
  }
  return nil
}

func (a *AccelData) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, a.X); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.Y); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.Z); err != nil {
    return err
  }
  return nil
}

func (a *AccelData) String() string {
  return fmt.Sprint("X: {", a.X, "} ",
    "Y: {", a.Y, "} ",
    "Z: {", a.Z, "}")
}


// STRUCTURE GyroData
type GyroData struct {
  X float32
  Y float32
  Z float32
}

func (g *GyroData) Size() uint32 {
  var result uint32
  result += 4 // X float_32
  result += 4 // Y float_32
  result += 4 // Z float_32
  return result
}

func (g *GyroData) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &g.X); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.Y); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.Z); err != nil {
    return err
  }
  return nil
}

func (g *GyroData) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, g.X); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.Y); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.Z); err != nil {
    return err
  }
  return nil
}

func (g *GyroData) String() string {
  return fmt.Sprint("X: {", g.X, "} ",
    "Y: {", g.Y, "} ",
    "Z: {", g.Z, "}")
}


// STRUCTURE CladPoint2d
type CladPoint2d struct {
  X float32
  Y float32
}

func (c *CladPoint2d) Size() uint32 {
  var result uint32
  result += 4 // X float_32
  result += 4 // Y float_32
  return result
}

func (c *CladPoint2d) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &c.X); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.Y); err != nil {
    return err
  }
  return nil
}

func (c *CladPoint2d) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, c.X); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.Y); err != nil {
    return err
  }
  return nil
}

func (c *CladPoint2d) String() string {
  return fmt.Sprint("X: {", c.X, "} ",
    "Y: {", c.Y, "}")
}


// STRUCTURE CladRect
type CladRect struct {
  XTopLeft float32
  YTopLeft float32
  Width float32
  Height float32
}

func (c *CladRect) Size() uint32 {
  var result uint32
  result += 4 // XTopLeft float_32
  result += 4 // YTopLeft float_32
  result += 4 // Width float_32
  result += 4 // Height float_32
  return result
}

func (c *CladRect) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &c.XTopLeft); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.YTopLeft); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.Width); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.Height); err != nil {
    return err
  }
  return nil
}

func (c *CladRect) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, c.XTopLeft); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.YTopLeft); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.Width); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.Height); err != nil {
    return err
  }
  return nil
}

func (c *CladRect) String() string {
  return fmt.Sprint("XTopLeft: {", c.XTopLeft, "} ",
    "YTopLeft: {", c.YTopLeft, "} ",
    "Width: {", c.Width, "} ",
    "Height: {", c.Height, "}")
}


// ENUM FacialExpression
type FacialExpression int8

const (
  FacialExpression_Unknown FacialExpression = FacialExpression(-1)           
  FacialExpression_Neutral FacialExpression = FacialExpression(0)            
  FacialExpression_Happiness FacialExpression = FacialExpression_Neutral + 1 
  FacialExpression_Surprise FacialExpression = FacialExpression_Happiness + 1
  FacialExpression_Anger FacialExpression = FacialExpression_Surprise + 1    
  FacialExpression_Sadness FacialExpression = FacialExpression_Anger + 1     
  FacialExpression_Count FacialExpression = FacialExpression_Sadness + 1     
)

// STRUCTURE SmileAmount
type SmileAmount struct {
  WasChecked bool
  Amount float32
  Confidence float32
}

func (s *SmileAmount) Size() uint32 {
  var result uint32
  result += 1 // WasChecked bool
  result += 4 // Amount float_32
  result += 4 // Confidence float_32
  return result
}

func (s *SmileAmount) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &s.WasChecked); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.Amount); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.Confidence); err != nil {
    return err
  }
  return nil
}

func (s *SmileAmount) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, s.WasChecked); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.Amount); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.Confidence); err != nil {
    return err
  }
  return nil
}

func (s *SmileAmount) String() string {
  return fmt.Sprint("WasChecked: {", s.WasChecked, "} ",
    "Amount: {", s.Amount, "} ",
    "Confidence: {", s.Confidence, "}")
}


// STRUCTURE Gaze
type Gaze struct {
  WasChecked bool
  LeftRightDeg float32
  UpDownDeg float32
}

func (g *Gaze) Size() uint32 {
  var result uint32
  result += 1 // WasChecked bool
  result += 4 // LeftRightDeg float_32
  result += 4 // UpDownDeg float_32
  return result
}

func (g *Gaze) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &g.WasChecked); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.LeftRightDeg); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.UpDownDeg); err != nil {
    return err
  }
  return nil
}

func (g *Gaze) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, g.WasChecked); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.LeftRightDeg); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.UpDownDeg); err != nil {
    return err
  }
  return nil
}

func (g *Gaze) String() string {
  return fmt.Sprint("WasChecked: {", g.WasChecked, "} ",
    "LeftRightDeg: {", g.LeftRightDeg, "} ",
    "UpDownDeg: {", g.UpDownDeg, "}")
}


// STRUCTURE BlinkAmount
type BlinkAmount struct {
  WasChecked bool
  BlinkAmountLeft float32
  BlinkAmountRight float32
}

func (b *BlinkAmount) Size() uint32 {
  var result uint32
  result += 1 // WasChecked bool
  result += 4 // BlinkAmountLeft float_32
  result += 4 // BlinkAmountRight float_32
  return result
}

func (b *BlinkAmount) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &b.WasChecked); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &b.BlinkAmountLeft); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &b.BlinkAmountRight); err != nil {
    return err
  }
  return nil
}

func (b *BlinkAmount) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, b.WasChecked); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, b.BlinkAmountLeft); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, b.BlinkAmountRight); err != nil {
    return err
  }
  return nil
}

func (b *BlinkAmount) String() string {
  return fmt.Sprint("WasChecked: {", b.WasChecked, "} ",
    "BlinkAmountLeft: {", b.BlinkAmountLeft, "} ",
    "BlinkAmountRight: {", b.BlinkAmountRight, "}")
}


// MESSAGE RobotObservedObject
type RobotObservedObject struct {
  Timestamp uint32
  ObjectFamily ObjectFamily
  ObjectType ObjectType
  ObjectID int32
  ImgRect CladRect
  Pose PoseStruct3d
  TopFaceOrientationRad float32
  IsActive uint8
}

func (r *RobotObservedObject) Size() uint32 {
  var result uint32
  result += 4 // Timestamp uint_32
  result += 4 // ObjectFamily ObjectFamily
  result += 4 // ObjectType ObjectType
  result += 4 // ObjectID int_32
  result += r.ImgRect.Size()
  result += r.Pose.Size()
  result += 4 // TopFaceOrientationRad float_32
  result += 1 // IsActive uint_8
  return result
}

func (r *RobotObservedObject) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &r.Timestamp); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.ObjectFamily); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.ObjectType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.ObjectID); err != nil {
    return err
  }
  if err := r.ImgRect.Unpack(buf); err != nil {
    return err
  }
  if err := r.Pose.Unpack(buf); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.TopFaceOrientationRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.IsActive); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedObject) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, r.Timestamp); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.ObjectFamily); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.ObjectType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.ObjectID); err != nil {
    return err
  }
  if err := r.ImgRect.Pack(buf); err != nil {
    return err
  }
  if err := r.Pose.Pack(buf); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.TopFaceOrientationRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.IsActive); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedObject) String() string {
  return fmt.Sprint("Timestamp: {", r.Timestamp, "} ",
    "ObjectFamily: {", r.ObjectFamily, "} ",
    "ObjectType: {", r.ObjectType, "} ",
    "ObjectID: {", r.ObjectID, "} ",
    "ImgRect: {", r.ImgRect, "} ",
    "Pose: {", r.Pose, "} ",
    "TopFaceOrientationRad: {", r.TopFaceOrientationRad, "} ",
    "IsActive: {", r.IsActive, "}")
}


// MESSAGE RobotObservedPossibleObject
type RobotObservedPossibleObject struct {
  PossibleObject RobotObservedObject
}

func (r *RobotObservedPossibleObject) Size() uint32 {
  var result uint32
  result += r.PossibleObject.Size()
  return result
}

func (r *RobotObservedPossibleObject) Unpack(buf *bytes.Buffer) error {
  if err := r.PossibleObject.Unpack(buf); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedPossibleObject) Pack(buf *bytes.Buffer) error {
  if err := r.PossibleObject.Pack(buf); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedPossibleObject) String() string {
  return fmt.Sprint("PossibleObject: {", r.PossibleObject, "}")
}


// MESSAGE RobotObservedFace
type RobotObservedFace struct {
  FaceID int32
  Timestamp uint32
  Pose PoseStruct3d
  ImgRect CladRect
  Name string
  Expression FacialExpression
  SmileAmount SmileAmount
  Gaze Gaze
  BlinkAmount BlinkAmount
  ExpressionValues []uint8
  LeftEye []CladPoint2d
  RightEye []CladPoint2d
  Nose []CladPoint2d
  Mouth []CladPoint2d
}

func (r *RobotObservedFace) Size() uint32 {
  var result uint32
  result += 4 // FaceID int_32
  result += 4 // Timestamp uint_32
  result += r.Pose.Size()
  result += r.ImgRect.Size()
  result += 1 // Name length (uint_8)
  result += uint32(len(r.Name)) // uint_8 array
  result += 1 // Expression FacialExpression
  result += r.SmileAmount.Size()
  result += r.Gaze.Size()
  result += r.BlinkAmount.Size()
  result += 1 // ExpressionValues length (uint_8)
  result += uint32(len(r.ExpressionValues)) // uint_8 array
  result += 1 // LeftEye length (uint_8)
  result += uint32(len(r.LeftEye)) * 8 // CladPoint2d array
  result += 1 // RightEye length (uint_8)
  result += uint32(len(r.RightEye)) * 8 // CladPoint2d array
  result += 1 // Nose length (uint_8)
  result += uint32(len(r.Nose)) * 8 // CladPoint2d array
  result += 1 // Mouth length (uint_8)
  result += uint32(len(r.Mouth)) * 8 // CladPoint2d array
  return result
}

func (r *RobotObservedFace) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &r.FaceID); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.Timestamp); err != nil {
    return err
  }
  if err := r.Pose.Unpack(buf); err != nil {
    return err
  }
  if err := r.ImgRect.Unpack(buf); err != nil {
    return err
  }
  var NameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &NameLen); err != nil {
    return err
  }
  r.Name = string(buf.Next(int(NameLen)))
  if len(r.Name) != int(NameLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.Expression); err != nil {
    return err
  }
  if err := r.SmileAmount.Unpack(buf); err != nil {
    return err
  }
  if err := r.Gaze.Unpack(buf); err != nil {
    return err
  }
  if err := r.BlinkAmount.Unpack(buf); err != nil {
    return err
  }
  var ExpressionValuesLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ExpressionValuesLen); err != nil {
    return err
  }
  r.ExpressionValues = make([]uint8, ExpressionValuesLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.ExpressionValues); err != nil {
    return err
  }
  var LeftEyeLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &LeftEyeLen); err != nil {
    return err
  }
  r.LeftEye = make([]CladPoint2d, LeftEyeLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.LeftEye); err != nil {
    return err
  }
  var RightEyeLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &RightEyeLen); err != nil {
    return err
  }
  r.RightEye = make([]CladPoint2d, RightEyeLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.RightEye); err != nil {
    return err
  }
  var NoseLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &NoseLen); err != nil {
    return err
  }
  r.Nose = make([]CladPoint2d, NoseLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.Nose); err != nil {
    return err
  }
  var MouthLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &MouthLen); err != nil {
    return err
  }
  r.Mouth = make([]CladPoint2d, MouthLen)
  if err := binary.Read(buf, binary.LittleEndian, &r.Mouth); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedFace) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, r.FaceID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.Timestamp); err != nil {
    return err
  }
  if err := r.Pose.Pack(buf); err != nil {
    return err
  }
  if err := r.ImgRect.Pack(buf); err != nil {
    return err
  }
  if len(r.Name) > 255 {
    return errors.New("max_length overflow in field Name")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.Name))); err != nil {
    return err
  }
  if _, err := buf.WriteString(r.Name); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.Expression); err != nil {
    return err
  }
  if err := r.SmileAmount.Pack(buf); err != nil {
    return err
  }
  if err := r.Gaze.Pack(buf); err != nil {
    return err
  }
  if err := r.BlinkAmount.Pack(buf); err != nil {
    return err
  }
  if len(r.ExpressionValues) > 255 {
    return errors.New("max_length overflow in field ExpressionValues")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.ExpressionValues))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.ExpressionValues); err != nil {
    return err
  }
  if len(r.LeftEye) > 255 {
    return errors.New("max_length overflow in field LeftEye")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.LeftEye))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.LeftEye); err != nil {
    return err
  }
  if len(r.RightEye) > 255 {
    return errors.New("max_length overflow in field RightEye")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.RightEye))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.RightEye); err != nil {
    return err
  }
  if len(r.Nose) > 255 {
    return errors.New("max_length overflow in field Nose")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.Nose))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.Nose); err != nil {
    return err
  }
  if len(r.Mouth) > 255 {
    return errors.New("max_length overflow in field Mouth")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.Mouth))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.Mouth); err != nil {
    return err
  }
  return nil
}

func (r *RobotObservedFace) String() string {
  return fmt.Sprint("FaceID: {", r.FaceID, "} ",
    "Timestamp: {", r.Timestamp, "} ",
    "Pose: {", r.Pose, "} ",
    "ImgRect: {", r.ImgRect, "} ",
    "Name: {", r.Name, "} ",
    "Expression: {", r.Expression, "} ",
    "SmileAmount: {", r.SmileAmount, "} ",
    "Gaze: {", r.Gaze, "} ",
    "BlinkAmount: {", r.BlinkAmount, "} ",
    "ExpressionValues: {", r.ExpressionValues, "} ",
    "LeftEye: {", r.LeftEye, "} ",
    "RightEye: {", r.RightEye, "} ",
    "Nose: {", r.Nose, "} ",
    "Mouth: {", r.Mouth, "}")
}


// MESSAGE RobotChangedObservedFaceID
type RobotChangedObservedFaceID struct {
  OldID int32
  NewID int32
}

func (r *RobotChangedObservedFaceID) Size() uint32 {
  var result uint32
  result += 4 // OldID int_32
  result += 4 // NewID int_32
  return result
}

func (r *RobotChangedObservedFaceID) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &r.OldID); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &r.NewID); err != nil {
    return err
  }
  return nil
}

func (r *RobotChangedObservedFaceID) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, r.OldID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, r.NewID); err != nil {
    return err
  }
  return nil
}

func (r *RobotChangedObservedFaceID) String() string {
  return fmt.Sprint("OldID: {", r.OldID, "} ",
    "NewID: {", r.NewID, "}")
}


// MESSAGE RequiredEmptyMessage
type RequiredEmptyMessage struct {
}

func (r *RequiredEmptyMessage) Size() uint32 {
  return 0
}

func (r *RequiredEmptyMessage) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (r *RequiredEmptyMessage) Pack(buf *bytes.Buffer) error {
  return nil
}

func (r *RequiredEmptyMessage) String() string {
  return ""
}


// UNION Event
type EventTag uint8

const (
  EventTag_ReplaceMe EventTag = iota // 0
  EventTag_INVALID   EventTag = 255
)

type Event struct {
  tag *EventTag
  value clad.Struct
}

func (m *Event) Tag() EventTag {
  if m.tag == nil {
    return EventTag_INVALID
  }
  return *m.tag
}

func (m *Event) Size() uint32 {
  if m.tag == nil || *m.tag == EventTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *Event) Pack(buf *bytes.Buffer) error {
  tag := EventTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == EventTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *Event) unpackStruct(tag EventTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case EventTag_ReplaceMe:
    var ret RequiredEmptyMessage
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *Event) Unpack(buf *bytes.Buffer) error {
  tag := EventTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == EventTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = EventTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t EventTag) String() string {
  switch t {
  case EventTag_ReplaceMe:
    return "ReplaceMe"
  default:
    return "INVALID"
  }
}

func (m *Event) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == EventTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *Event) GetReplaceMe() *RequiredEmptyMessage {
  if m.tag == nil || *m.tag != EventTag_ReplaceMe {
    return nil
  }
  return m.value.(*RequiredEmptyMessage)
}

func (m *Event) SetReplaceMe(value *RequiredEmptyMessage) {
  newTag := EventTag_ReplaceMe
  m.tag = &newTag
  m.value = value
}

func NewEventWithReplaceMe(value *RequiredEmptyMessage) *Event {
  var ret Event
  ret.SetReplaceMe(value)
  return &ret
}


// MESSAGE RobotDeletedFixedCustomObjects
type RobotDeletedFixedCustomObjects struct {
}

func (r *RobotDeletedFixedCustomObjects) Size() uint32 {
  return 0
}

func (r *RobotDeletedFixedCustomObjects) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotDeletedFixedCustomObjects) Pack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotDeletedFixedCustomObjects) String() string {
  return ""
}


// MESSAGE RobotDeletedCustomMarkerObjects
type RobotDeletedCustomMarkerObjects struct {
}

func (r *RobotDeletedCustomMarkerObjects) Size() uint32 {
  return 0
}

func (r *RobotDeletedCustomMarkerObjects) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotDeletedCustomMarkerObjects) Pack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotDeletedCustomMarkerObjects) String() string {
  return ""
}


// MESSAGE CreatedFixedCustomObject
type CreatedFixedCustomObject struct {
  ObjectID uint32
}

func (c *CreatedFixedCustomObject) Size() uint32 {
  var result uint32
  result += 4 // ObjectID uint_32
  return result
}

func (c *CreatedFixedCustomObject) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &c.ObjectID); err != nil {
    return err
  }
  return nil
}

func (c *CreatedFixedCustomObject) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, c.ObjectID); err != nil {
    return err
  }
  return nil
}

func (c *CreatedFixedCustomObject) String() string {
  return fmt.Sprint("ObjectID: {", c.ObjectID, "}")
}


// MESSAGE DefinedCustomObject
type DefinedCustomObject struct {
  Success bool
}

func (d *DefinedCustomObject) Size() uint32 {
  var result uint32
  result += 1 // Success bool
  return result
}

func (d *DefinedCustomObject) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.Success); err != nil {
    return err
  }
  return nil
}

func (d *DefinedCustomObject) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.Success); err != nil {
    return err
  }
  return nil
}

func (d *DefinedCustomObject) String() string {
  return fmt.Sprint("Success: {", d.Success, "}")
}


// ENUM ENodeContentTypeEnum
type ENodeContentTypeEnum uint8

const (
  ENodeContentTypeEnum_Unknown ENodeContentTypeEnum = iota
  ENodeContentTypeEnum_ClearOfObstacle                    
  ENodeContentTypeEnum_ClearOfCliff                       
  ENodeContentTypeEnum_ObstacleCube                       
  ENodeContentTypeEnum_ObstacleProx                       
  ENodeContentTypeEnum_ObstacleProxExplored               
  ENodeContentTypeEnum_ObstacleUnrecognized               
  ENodeContentTypeEnum_Cliff                              
  ENodeContentTypeEnum_InterestingEdge                    
  ENodeContentTypeEnum_NotInterestingEdge                 
)

// STRUCTURE MemoryMapQuadInfo
type MemoryMapQuadInfo struct {
  Content ENodeContentTypeEnum
  Depth uint8
  ColorRGBA uint32
}

func (m *MemoryMapQuadInfo) Size() uint32 {
  var result uint32
  result += 1 // Content ENodeContentTypeEnum
  result += 1 // Depth uint_8
  result += 4 // ColorRGBA uint_32
  return result
}

func (m *MemoryMapQuadInfo) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &m.Content); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.Depth); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.ColorRGBA); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapQuadInfo) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, m.Content); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.Depth); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.ColorRGBA); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapQuadInfo) String() string {
  return fmt.Sprint("Content: {", m.Content, "} ",
    "Depth: {", m.Depth, "} ",
    "ColorRGBA: {", m.ColorRGBA, "}")
}


// MESSAGE MemoryMapMessageBegin
type MemoryMapMessageBegin struct {
  OriginId uint32
  RootDepth int32
  RootSizeMm float32
  RootCenterX float32
  RootCenterY float32
}

func (m *MemoryMapMessageBegin) Size() uint32 {
  var result uint32
  result += 4 // OriginId uint_32
  result += 4 // RootDepth int_32
  result += 4 // RootSizeMm float_32
  result += 4 // RootCenterX float_32
  result += 4 // RootCenterY float_32
  return result
}

func (m *MemoryMapMessageBegin) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &m.OriginId); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.RootDepth); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.RootSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.RootCenterX); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &m.RootCenterY); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapMessageBegin) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, m.OriginId); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.RootDepth); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.RootSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.RootCenterX); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.RootCenterY); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapMessageBegin) String() string {
  return fmt.Sprint("OriginId: {", m.OriginId, "} ",
    "RootDepth: {", m.RootDepth, "} ",
    "RootSizeMm: {", m.RootSizeMm, "} ",
    "RootCenterX: {", m.RootCenterX, "} ",
    "RootCenterY: {", m.RootCenterY, "}")
}


// MESSAGE MemoryMapMessage
type MemoryMapMessage struct {
  QuadInfos []MemoryMapQuadInfo
}

func (m *MemoryMapMessage) Size() uint32 {
  var result uint32
  result += 2 // QuadInfos length (uint_16)
  result += uint32(len(m.QuadInfos)) * 6 // MemoryMapQuadInfo array
  return result
}

func (m *MemoryMapMessage) Unpack(buf *bytes.Buffer) error {
  var QuadInfosLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &QuadInfosLen); err != nil {
    return err
  }
  m.QuadInfos = make([]MemoryMapQuadInfo, QuadInfosLen)
  if err := binary.Read(buf, binary.LittleEndian, &m.QuadInfos); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapMessage) Pack(buf *bytes.Buffer) error {
  if len(m.QuadInfos) > 65535 {
    return errors.New("max_length overflow in field QuadInfos")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(m.QuadInfos))); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, m.QuadInfos); err != nil {
    return err
  }
  return nil
}

func (m *MemoryMapMessage) String() string {
  return fmt.Sprint("QuadInfos: {", m.QuadInfos, "}")
}


// MESSAGE MemoryMapMessageEnd
type MemoryMapMessageEnd struct {
}

func (m *MemoryMapMessageEnd) Size() uint32 {
  return 0
}

func (m *MemoryMapMessageEnd) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (m *MemoryMapMessageEnd) Pack(buf *bytes.Buffer) error {
  return nil
}

func (m *MemoryMapMessageEnd) String() string {
  return ""
}


// UNION MessageRobotToExternal
type MessageRobotToExternalTag uint8

const (
  MessageRobotToExternalTag_UiDeviceConnected               MessageRobotToExternalTag = 0x0  // 0
  MessageRobotToExternalTag_RobotCompletedAction            MessageRobotToExternalTag = 0x1  // 1
  MessageRobotToExternalTag_Event                           MessageRobotToExternalTag = 0x2  // 2
  MessageRobotToExternalTag_EnrolledNamesResponse           MessageRobotToExternalTag = 0x5  // 5
  MessageRobotToExternalTag_RobotObservedFace               MessageRobotToExternalTag = 0x6  // 6
  MessageRobotToExternalTag_RobotChangedObservedFaceID      MessageRobotToExternalTag = 0x7  // 7
  MessageRobotToExternalTag_ObjectConnectionState           MessageRobotToExternalTag = 0xa  // 10
  MessageRobotToExternalTag_ObjectMoved                     MessageRobotToExternalTag = 0xb  // 11
  MessageRobotToExternalTag_ObjectStoppedMoving             MessageRobotToExternalTag = 0xc  // 12
  MessageRobotToExternalTag_ObjectUpAxisChanged             MessageRobotToExternalTag = 0xd  // 13
  MessageRobotToExternalTag_ObjectTapped                    MessageRobotToExternalTag = 0xe  // 14
  MessageRobotToExternalTag_ObjectAccel                     MessageRobotToExternalTag = 0xf  // 15
  MessageRobotToExternalTag_RobotObservedObject             MessageRobotToExternalTag = 0x10 // 16
  MessageRobotToExternalTag_ObjectAvailable                 MessageRobotToExternalTag = 0x11 // 17
  MessageRobotToExternalTag_RobotDeletedFixedCustomObjects  MessageRobotToExternalTag = 0x12 // 18
  MessageRobotToExternalTag_RobotDeletedCustomMarkerObjects MessageRobotToExternalTag = 0x13 // 19
  MessageRobotToExternalTag_CreatedFixedCustomObject        MessageRobotToExternalTag = 0x14 // 20
  MessageRobotToExternalTag_DefinedCustomObject             MessageRobotToExternalTag = 0x15 // 21
  MessageRobotToExternalTag_MemoryMapMessageBegin           MessageRobotToExternalTag = 0x16 // 22
  MessageRobotToExternalTag_MemoryMapMessage                MessageRobotToExternalTag = 0x17 // 23
  MessageRobotToExternalTag_MemoryMapMessageEnd             MessageRobotToExternalTag = 0x18 // 24
  MessageRobotToExternalTag_INVALID                         MessageRobotToExternalTag = 255
)

type MessageRobotToExternal struct {
  tag *MessageRobotToExternalTag
  value clad.Struct
}

func (m *MessageRobotToExternal) Tag() MessageRobotToExternalTag {
  if m.tag == nil {
    return MessageRobotToExternalTag_INVALID
  }
  return *m.tag
}

func (m *MessageRobotToExternal) Size() uint32 {
  if m.tag == nil || *m.tag == MessageRobotToExternalTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *MessageRobotToExternal) Pack(buf *bytes.Buffer) error {
  tag := MessageRobotToExternalTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == MessageRobotToExternalTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *MessageRobotToExternal) unpackStruct(tag MessageRobotToExternalTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case MessageRobotToExternalTag_UiDeviceConnected:
    var ret UiDeviceConnected
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotCompletedAction:
    var ret RobotCompletedAction
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_Event:
    var ret Event
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_EnrolledNamesResponse:
    var ret EnrolledNamesResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotObservedFace:
    var ret RobotObservedFace
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotChangedObservedFaceID:
    var ret RobotChangedObservedFaceID
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectConnectionState:
    var ret ObjectConnectionState
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectMoved:
    var ret ObjectMoved
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectStoppedMoving:
    var ret ObjectStoppedMoving
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectUpAxisChanged:
    var ret ObjectUpAxisChanged
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectTapped:
    var ret ObjectTapped
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectAccel:
    var ret ObjectAccel
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotObservedObject:
    var ret RobotObservedObject
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_ObjectAvailable:
    var ret ObjectAvailable
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotDeletedFixedCustomObjects:
    var ret RobotDeletedFixedCustomObjects
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_RobotDeletedCustomMarkerObjects:
    var ret RobotDeletedCustomMarkerObjects
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_CreatedFixedCustomObject:
    var ret CreatedFixedCustomObject
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_DefinedCustomObject:
    var ret DefinedCustomObject
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_MemoryMapMessageBegin:
    var ret MemoryMapMessageBegin
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_MemoryMapMessage:
    var ret MemoryMapMessage
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageRobotToExternalTag_MemoryMapMessageEnd:
    var ret MemoryMapMessageEnd
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *MessageRobotToExternal) Unpack(buf *bytes.Buffer) error {
  tag := MessageRobotToExternalTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == MessageRobotToExternalTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = MessageRobotToExternalTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t MessageRobotToExternalTag) String() string {
  switch t {
  case MessageRobotToExternalTag_UiDeviceConnected:
    return "UiDeviceConnected"
  case MessageRobotToExternalTag_RobotCompletedAction:
    return "RobotCompletedAction"
  case MessageRobotToExternalTag_Event:
    return "Event"
  case MessageRobotToExternalTag_EnrolledNamesResponse:
    return "EnrolledNamesResponse"
  case MessageRobotToExternalTag_RobotObservedFace:
    return "RobotObservedFace"
  case MessageRobotToExternalTag_RobotChangedObservedFaceID:
    return "RobotChangedObservedFaceID"
  case MessageRobotToExternalTag_ObjectConnectionState:
    return "ObjectConnectionState"
  case MessageRobotToExternalTag_ObjectMoved:
    return "ObjectMoved"
  case MessageRobotToExternalTag_ObjectStoppedMoving:
    return "ObjectStoppedMoving"
  case MessageRobotToExternalTag_ObjectUpAxisChanged:
    return "ObjectUpAxisChanged"
  case MessageRobotToExternalTag_ObjectTapped:
    return "ObjectTapped"
  case MessageRobotToExternalTag_ObjectAccel:
    return "ObjectAccel"
  case MessageRobotToExternalTag_RobotObservedObject:
    return "RobotObservedObject"
  case MessageRobotToExternalTag_ObjectAvailable:
    return "ObjectAvailable"
  case MessageRobotToExternalTag_RobotDeletedFixedCustomObjects:
    return "RobotDeletedFixedCustomObjects"
  case MessageRobotToExternalTag_RobotDeletedCustomMarkerObjects:
    return "RobotDeletedCustomMarkerObjects"
  case MessageRobotToExternalTag_CreatedFixedCustomObject:
    return "CreatedFixedCustomObject"
  case MessageRobotToExternalTag_DefinedCustomObject:
    return "DefinedCustomObject"
  case MessageRobotToExternalTag_MemoryMapMessageBegin:
    return "MemoryMapMessageBegin"
  case MessageRobotToExternalTag_MemoryMapMessage:
    return "MemoryMapMessage"
  case MessageRobotToExternalTag_MemoryMapMessageEnd:
    return "MemoryMapMessageEnd"
  default:
    return "INVALID"
  }
}

func (m *MessageRobotToExternal) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == MessageRobotToExternalTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *MessageRobotToExternal) GetUiDeviceConnected() *UiDeviceConnected {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_UiDeviceConnected {
    return nil
  }
  return m.value.(*UiDeviceConnected)
}

func (m *MessageRobotToExternal) SetUiDeviceConnected(value *UiDeviceConnected) {
  newTag := MessageRobotToExternalTag_UiDeviceConnected
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithUiDeviceConnected(value *UiDeviceConnected) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetUiDeviceConnected(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotCompletedAction() *RobotCompletedAction {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotCompletedAction {
    return nil
  }
  return m.value.(*RobotCompletedAction)
}

func (m *MessageRobotToExternal) SetRobotCompletedAction(value *RobotCompletedAction) {
  newTag := MessageRobotToExternalTag_RobotCompletedAction
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotCompletedAction(value *RobotCompletedAction) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotCompletedAction(value)
  return &ret
}

func (m *MessageRobotToExternal) GetEvent() *Event {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_Event {
    return nil
  }
  return m.value.(*Event)
}

func (m *MessageRobotToExternal) SetEvent(value *Event) {
  newTag := MessageRobotToExternalTag_Event
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithEvent(value *Event) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetEvent(value)
  return &ret
}

func (m *MessageRobotToExternal) GetEnrolledNamesResponse() *EnrolledNamesResponse {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_EnrolledNamesResponse {
    return nil
  }
  return m.value.(*EnrolledNamesResponse)
}

func (m *MessageRobotToExternal) SetEnrolledNamesResponse(value *EnrolledNamesResponse) {
  newTag := MessageRobotToExternalTag_EnrolledNamesResponse
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithEnrolledNamesResponse(value *EnrolledNamesResponse) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetEnrolledNamesResponse(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotObservedFace() *RobotObservedFace {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotObservedFace {
    return nil
  }
  return m.value.(*RobotObservedFace)
}

func (m *MessageRobotToExternal) SetRobotObservedFace(value *RobotObservedFace) {
  newTag := MessageRobotToExternalTag_RobotObservedFace
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotObservedFace(value *RobotObservedFace) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotObservedFace(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotChangedObservedFaceID() *RobotChangedObservedFaceID {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotChangedObservedFaceID {
    return nil
  }
  return m.value.(*RobotChangedObservedFaceID)
}

func (m *MessageRobotToExternal) SetRobotChangedObservedFaceID(value *RobotChangedObservedFaceID) {
  newTag := MessageRobotToExternalTag_RobotChangedObservedFaceID
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotChangedObservedFaceID(value *RobotChangedObservedFaceID) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotChangedObservedFaceID(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectConnectionState() *ObjectConnectionState {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectConnectionState {
    return nil
  }
  return m.value.(*ObjectConnectionState)
}

func (m *MessageRobotToExternal) SetObjectConnectionState(value *ObjectConnectionState) {
  newTag := MessageRobotToExternalTag_ObjectConnectionState
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectConnectionState(value *ObjectConnectionState) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectConnectionState(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectMoved() *ObjectMoved {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectMoved {
    return nil
  }
  return m.value.(*ObjectMoved)
}

func (m *MessageRobotToExternal) SetObjectMoved(value *ObjectMoved) {
  newTag := MessageRobotToExternalTag_ObjectMoved
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectMoved(value *ObjectMoved) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectMoved(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectStoppedMoving() *ObjectStoppedMoving {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectStoppedMoving {
    return nil
  }
  return m.value.(*ObjectStoppedMoving)
}

func (m *MessageRobotToExternal) SetObjectStoppedMoving(value *ObjectStoppedMoving) {
  newTag := MessageRobotToExternalTag_ObjectStoppedMoving
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectStoppedMoving(value *ObjectStoppedMoving) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectStoppedMoving(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectUpAxisChanged() *ObjectUpAxisChanged {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectUpAxisChanged {
    return nil
  }
  return m.value.(*ObjectUpAxisChanged)
}

func (m *MessageRobotToExternal) SetObjectUpAxisChanged(value *ObjectUpAxisChanged) {
  newTag := MessageRobotToExternalTag_ObjectUpAxisChanged
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectUpAxisChanged(value *ObjectUpAxisChanged) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectUpAxisChanged(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectTapped() *ObjectTapped {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectTapped {
    return nil
  }
  return m.value.(*ObjectTapped)
}

func (m *MessageRobotToExternal) SetObjectTapped(value *ObjectTapped) {
  newTag := MessageRobotToExternalTag_ObjectTapped
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectTapped(value *ObjectTapped) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectTapped(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectAccel() *ObjectAccel {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectAccel {
    return nil
  }
  return m.value.(*ObjectAccel)
}

func (m *MessageRobotToExternal) SetObjectAccel(value *ObjectAccel) {
  newTag := MessageRobotToExternalTag_ObjectAccel
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectAccel(value *ObjectAccel) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectAccel(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotObservedObject() *RobotObservedObject {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotObservedObject {
    return nil
  }
  return m.value.(*RobotObservedObject)
}

func (m *MessageRobotToExternal) SetRobotObservedObject(value *RobotObservedObject) {
  newTag := MessageRobotToExternalTag_RobotObservedObject
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotObservedObject(value *RobotObservedObject) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotObservedObject(value)
  return &ret
}

func (m *MessageRobotToExternal) GetObjectAvailable() *ObjectAvailable {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_ObjectAvailable {
    return nil
  }
  return m.value.(*ObjectAvailable)
}

func (m *MessageRobotToExternal) SetObjectAvailable(value *ObjectAvailable) {
  newTag := MessageRobotToExternalTag_ObjectAvailable
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithObjectAvailable(value *ObjectAvailable) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetObjectAvailable(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotDeletedFixedCustomObjects() *RobotDeletedFixedCustomObjects {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotDeletedFixedCustomObjects {
    return nil
  }
  return m.value.(*RobotDeletedFixedCustomObjects)
}

func (m *MessageRobotToExternal) SetRobotDeletedFixedCustomObjects(value *RobotDeletedFixedCustomObjects) {
  newTag := MessageRobotToExternalTag_RobotDeletedFixedCustomObjects
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotDeletedFixedCustomObjects(value *RobotDeletedFixedCustomObjects) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotDeletedFixedCustomObjects(value)
  return &ret
}

func (m *MessageRobotToExternal) GetRobotDeletedCustomMarkerObjects() *RobotDeletedCustomMarkerObjects {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_RobotDeletedCustomMarkerObjects {
    return nil
  }
  return m.value.(*RobotDeletedCustomMarkerObjects)
}

func (m *MessageRobotToExternal) SetRobotDeletedCustomMarkerObjects(value *RobotDeletedCustomMarkerObjects) {
  newTag := MessageRobotToExternalTag_RobotDeletedCustomMarkerObjects
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithRobotDeletedCustomMarkerObjects(value *RobotDeletedCustomMarkerObjects) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetRobotDeletedCustomMarkerObjects(value)
  return &ret
}

func (m *MessageRobotToExternal) GetCreatedFixedCustomObject() *CreatedFixedCustomObject {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_CreatedFixedCustomObject {
    return nil
  }
  return m.value.(*CreatedFixedCustomObject)
}

func (m *MessageRobotToExternal) SetCreatedFixedCustomObject(value *CreatedFixedCustomObject) {
  newTag := MessageRobotToExternalTag_CreatedFixedCustomObject
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithCreatedFixedCustomObject(value *CreatedFixedCustomObject) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetCreatedFixedCustomObject(value)
  return &ret
}

func (m *MessageRobotToExternal) GetDefinedCustomObject() *DefinedCustomObject {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_DefinedCustomObject {
    return nil
  }
  return m.value.(*DefinedCustomObject)
}

func (m *MessageRobotToExternal) SetDefinedCustomObject(value *DefinedCustomObject) {
  newTag := MessageRobotToExternalTag_DefinedCustomObject
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithDefinedCustomObject(value *DefinedCustomObject) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetDefinedCustomObject(value)
  return &ret
}

func (m *MessageRobotToExternal) GetMemoryMapMessageBegin() *MemoryMapMessageBegin {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_MemoryMapMessageBegin {
    return nil
  }
  return m.value.(*MemoryMapMessageBegin)
}

func (m *MessageRobotToExternal) SetMemoryMapMessageBegin(value *MemoryMapMessageBegin) {
  newTag := MessageRobotToExternalTag_MemoryMapMessageBegin
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithMemoryMapMessageBegin(value *MemoryMapMessageBegin) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetMemoryMapMessageBegin(value)
  return &ret
}

func (m *MessageRobotToExternal) GetMemoryMapMessage() *MemoryMapMessage {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_MemoryMapMessage {
    return nil
  }
  return m.value.(*MemoryMapMessage)
}

func (m *MessageRobotToExternal) SetMemoryMapMessage(value *MemoryMapMessage) {
  newTag := MessageRobotToExternalTag_MemoryMapMessage
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithMemoryMapMessage(value *MemoryMapMessage) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetMemoryMapMessage(value)
  return &ret
}

func (m *MessageRobotToExternal) GetMemoryMapMessageEnd() *MemoryMapMessageEnd {
  if m.tag == nil || *m.tag != MessageRobotToExternalTag_MemoryMapMessageEnd {
    return nil
  }
  return m.value.(*MemoryMapMessageEnd)
}

func (m *MessageRobotToExternal) SetMemoryMapMessageEnd(value *MemoryMapMessageEnd) {
  newTag := MessageRobotToExternalTag_MemoryMapMessageEnd
  m.tag = &newTag
  m.value = value
}

func NewMessageRobotToExternalWithMemoryMapMessageEnd(value *MemoryMapMessageEnd) *MessageRobotToExternal {
  var ret MessageRobotToExternal
  ret.SetMemoryMapMessageEnd(value)
  return &ret
}