messageRobotToExternal.go

// 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"
	"fmt"

	"github.com/digital-dream-labs/vector-cloud/internal/clad"
)

// 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
}