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

package gateway

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"

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

// MESSAGE UiDeviceConnectionWrongVersion
type UiDeviceConnectionWrongVersion struct {
	PlaceHolder string
}

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

func (u *UiDeviceConnectionWrongVersion) 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 *UiDeviceConnectionWrongVersion) 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 *UiDeviceConnectionWrongVersion) String() string {
	return fmt.Sprint("PlaceHolder: {", u.PlaceHolder, "}")
}

// MESSAGE MoveHead
type MoveHead struct {
	SpeedRadPerSec float32
}

func (m *MoveHead) Size() uint32 {
	var result uint32
	result += 4 // SpeedRadPerSec float_32
	return result
}

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

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

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

// MESSAGE MoveLift
type MoveLift struct {
	SpeedRadPerSec float32
}

func (m *MoveLift) Size() uint32 {
	var result uint32
	result += 4 // SpeedRadPerSec float_32
	return result
}

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

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

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

// MESSAGE DriveArc
type DriveArc struct {
	Speed             float32
	Accel             float32
	CurvatureRadiusMm int16
}

func (d *DriveArc) Size() uint32 {
	var result uint32
	result += 4 // Speed float_32
	result += 4 // Accel float_32
	result += 2 // CurvatureRadiusMm int_16
	return result
}

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

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

func (d *DriveArc) String() string {
	return fmt.Sprint("Speed: {", d.Speed, "} ",
		"Accel: {", d.Accel, "} ",
		"CurvatureRadiusMm: {", d.CurvatureRadiusMm, "}")
}

// MESSAGE DisplayFaceImageRGBChunk
type DisplayFaceImageRGBChunk struct {
	FaceData         [600]uint16
	NumPixels        uint16
	ChunkIndex       uint8
	NumChunks        uint8
	DurationMs       uint32
	InterruptRunning bool
}

func (d *DisplayFaceImageRGBChunk) Size() uint32 {
	var result uint32
	result += 600 * 2 // uint_16 array
	result += 2       // NumPixels uint_16
	result += 1       // ChunkIndex uint_8
	result += 1       // NumChunks uint_8
	result += 4       // DurationMs uint_32
	result += 1       // InterruptRunning bool
	return result
}

func (d *DisplayFaceImageRGBChunk) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &d.FaceData); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.NumPixels); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.ChunkIndex); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.NumChunks); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.DurationMs); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.InterruptRunning); err != nil {
		return err
	}
	return nil
}

func (d *DisplayFaceImageRGBChunk) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, d.FaceData); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.NumPixels); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.ChunkIndex); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.NumChunks); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.DurationMs); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.InterruptRunning); err != nil {
		return err
	}
	return nil
}

func (d *DisplayFaceImageRGBChunk) String() string {
	return fmt.Sprint("FaceData: {", d.FaceData, "} ",
		"NumPixels: {", d.NumPixels, "} ",
		"ChunkIndex: {", d.ChunkIndex, "} ",
		"NumChunks: {", d.NumChunks, "} ",
		"DurationMs: {", d.DurationMs, "} ",
		"InterruptRunning: {", d.InterruptRunning, "}")
}

// MESSAGE RobotHistoryRequest
type RobotHistoryRequest struct {
}

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

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

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

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

// MESSAGE AppIntent
type AppIntent struct {
	Intent string
	Param  string
}

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

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

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

func (a *AppIntent) String() string {
	return fmt.Sprint("Intent: {", a.Intent, "} ",
		"Param: {", a.Param, "}")
}

// MESSAGE CancelFaceEnrollment
type CancelFaceEnrollment struct {
}

func (c *CancelFaceEnrollment) Size() uint32 {
	return 0
}

func (c *CancelFaceEnrollment) Unpack(buf *bytes.Buffer) error {
	return nil
}

func (c *CancelFaceEnrollment) Pack(buf *bytes.Buffer) error {
	return nil
}

func (c *CancelFaceEnrollment) String() string {
	return ""
}

// MESSAGE RequestEnrolledNames
type RequestEnrolledNames struct {
}

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

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

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

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

// MESSAGE UpdateEnrolledFaceByID
type UpdateEnrolledFaceByID struct {
	FaceID  int32
	OldName string
	NewName string
}

func (u *UpdateEnrolledFaceByID) Size() uint32 {
	var result uint32
	result += 4                      // FaceID int_32
	result += 1                      // OldName length (uint_8)
	result += uint32(len(u.OldName)) // uint_8 array
	result += 1                      // NewName length (uint_8)
	result += uint32(len(u.NewName)) // uint_8 array
	return result
}

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

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

func (u *UpdateEnrolledFaceByID) String() string {
	return fmt.Sprint("FaceID: {", u.FaceID, "} ",
		"OldName: {", u.OldName, "} ",
		"NewName: {", u.NewName, "}")
}

// MESSAGE EraseEnrolledFaceByID
type EraseEnrolledFaceByID struct {
	FaceID int32
}

func (e *EraseEnrolledFaceByID) Size() uint32 {
	var result uint32
	result += 4 // FaceID int_32
	return result
}

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

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

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

// MESSAGE EraseAllEnrolledFaces
type EraseAllEnrolledFaces struct {
}

func (e *EraseAllEnrolledFaces) Size() uint32 {
	return 0
}

func (e *EraseAllEnrolledFaces) Unpack(buf *bytes.Buffer) error {
	return nil
}

func (e *EraseAllEnrolledFaces) Pack(buf *bytes.Buffer) error {
	return nil
}

func (e *EraseAllEnrolledFaces) String() string {
	return ""
}

// MESSAGE SetFaceToEnroll
type SetFaceToEnroll struct {
	Name        string
	ObservedID  int32
	SaveID      int32
	SaveToRobot bool
	SayName     bool
	UseMusic    bool
}

func (s *SetFaceToEnroll) Size() uint32 {
	var result uint32
	result += 1                   // Name length (uint_8)
	result += uint32(len(s.Name)) // uint_8 array
	result += 4                   // ObservedID int_32
	result += 4                   // SaveID int_32
	result += 1                   // SaveToRobot bool
	result += 1                   // SayName bool
	result += 1                   // UseMusic bool
	return result
}

func (s *SetFaceToEnroll) Unpack(buf *bytes.Buffer) error {
	var NameLen uint8
	if err := binary.Read(buf, binary.LittleEndian, &NameLen); err != nil {
		return err
	}
	s.Name = string(buf.Next(int(NameLen)))
	if len(s.Name) != int(NameLen) {
		return errors.New("string byte mismatch")
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.ObservedID); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.SaveID); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.SaveToRobot); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.SayName); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.UseMusic); err != nil {
		return err
	}
	return nil
}

func (s *SetFaceToEnroll) Pack(buf *bytes.Buffer) error {
	if len(s.Name) > 255 {
		return errors.New("max_length overflow in field Name")
	}
	if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.Name))); err != nil {
		return err
	}
	if _, err := buf.WriteString(s.Name); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.ObservedID); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.SaveID); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.SaveToRobot); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.SayName); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.UseMusic); err != nil {
		return err
	}
	return nil
}

func (s *SetFaceToEnroll) String() string {
	return fmt.Sprint("Name: {", s.Name, "} ",
		"ObservedID: {", s.ObservedID, "} ",
		"SaveID: {", s.SaveID, "} ",
		"SaveToRobot: {", s.SaveToRobot, "} ",
		"SayName: {", s.SayName, "} ",
		"UseMusic: {", s.UseMusic, "}")
}

// ENUM VisionMode
type VisionMode uint32

const (
	VisionMode_Faces VisionMode = VisionMode(0x1)
)

// MESSAGE EnableVisionMode
type EnableVisionMode struct {
	Mode   VisionMode
	Enable bool
}

func (e *EnableVisionMode) Size() uint32 {
	var result uint32
	result += 4 // Mode VisionMode
	result += 1 // Enable bool
	return result
}

func (e *EnableVisionMode) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &e.Mode); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &e.Enable); err != nil {
		return err
	}
	return nil
}

func (e *EnableVisionMode) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, e.Mode); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, e.Enable); err != nil {
		return err
	}
	return nil
}

func (e *EnableVisionMode) String() string {
	return fmt.Sprint("Mode: {", e.Mode, "} ",
		"Enable: {", e.Enable, "}")
}

// STRUCTURE PathMotionProfile
type PathMotionProfile struct {
	SpeedMmps                float32
	AccelMmps2               float32
	DecelMmps2               float32
	PointTurnSpeedRadPerSec  float32
	PointTurnAccelRadPerSec2 float32
	PointTurnDecelRadPerSec2 float32
	DockSpeedMmps            float32
	DockAccelMmps2           float32
	DockDecelMmps2           float32
	ReverseSpeedMmps         float32
	IsCustom                 bool
}

func (p *PathMotionProfile) Size() uint32 {
	var result uint32
	result += 4 // SpeedMmps float_32
	result += 4 // AccelMmps2 float_32
	result += 4 // DecelMmps2 float_32
	result += 4 // PointTurnSpeedRadPerSec float_32
	result += 4 // PointTurnAccelRadPerSec2 float_32
	result += 4 // PointTurnDecelRadPerSec2 float_32
	result += 4 // DockSpeedMmps float_32
	result += 4 // DockAccelMmps2 float_32
	result += 4 // DockDecelMmps2 float_32
	result += 4 // ReverseSpeedMmps float_32
	result += 1 // IsCustom bool
	return result
}

func (p *PathMotionProfile) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &p.SpeedMmps); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.AccelMmps2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.DecelMmps2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnAccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnDecelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.DockSpeedMmps); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.DockAccelMmps2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.DockDecelMmps2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.ReverseSpeedMmps); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &p.IsCustom); err != nil {
		return err
	}
	return nil
}

func (p *PathMotionProfile) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, p.SpeedMmps); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.AccelMmps2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.DecelMmps2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.PointTurnSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.PointTurnAccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.PointTurnDecelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.DockSpeedMmps); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.DockAccelMmps2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.DockDecelMmps2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.ReverseSpeedMmps); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, p.IsCustom); err != nil {
		return err
	}
	return nil
}

func (p *PathMotionProfile) String() string {
	return fmt.Sprint("SpeedMmps: {", p.SpeedMmps, "} ",
		"AccelMmps2: {", p.AccelMmps2, "} ",
		"DecelMmps2: {", p.DecelMmps2, "} ",
		"PointTurnSpeedRadPerSec: {", p.PointTurnSpeedRadPerSec, "} ",
		"PointTurnAccelRadPerSec2: {", p.PointTurnAccelRadPerSec2, "} ",
		"PointTurnDecelRadPerSec2: {", p.PointTurnDecelRadPerSec2, "} ",
		"DockSpeedMmps: {", p.DockSpeedMmps, "} ",
		"DockAccelMmps2: {", p.DockAccelMmps2, "} ",
		"DockDecelMmps2: {", p.DockDecelMmps2, "} ",
		"ReverseSpeedMmps: {", p.ReverseSpeedMmps, "} ",
		"IsCustom: {", p.IsCustom, "}")
}

// MESSAGE GotoPose
type GotoPose struct {
	XMm        float32
	YMm        float32
	Rad        float32
	MotionProf PathMotionProfile
	Level      uint8
}

func (g *GotoPose) Size() uint32 {
	var result uint32
	result += 4 // XMm float_32
	result += 4 // YMm float_32
	result += 4 // Rad float_32
	result += g.MotionProf.Size()
	result += 1 // Level uint_8
	return result
}

func (g *GotoPose) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &g.XMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &g.YMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &g.Rad); err != nil {
		return err
	}
	if err := g.MotionProf.Unpack(buf); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &g.Level); err != nil {
		return err
	}
	return nil
}

func (g *GotoPose) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, g.XMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, g.YMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, g.Rad); err != nil {
		return err
	}
	if err := g.MotionProf.Pack(buf); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, g.Level); err != nil {
		return err
	}
	return nil
}

func (g *GotoPose) String() string {
	return fmt.Sprint("XMm: {", g.XMm, "} ",
		"YMm: {", g.YMm, "} ",
		"Rad: {", g.Rad, "} ",
		"MotionProf: {", g.MotionProf, "} ",
		"Level: {", g.Level, "}")
}

// MESSAGE DriveStraight
type DriveStraight struct {
	SpeedMmps           float32
	DistMm              float32
	ShouldPlayAnimation bool
}

func (d *DriveStraight) Size() uint32 {
	var result uint32
	result += 4 // SpeedMmps float_32
	result += 4 // DistMm float_32
	result += 1 // ShouldPlayAnimation bool
	return result
}

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

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

func (d *DriveStraight) String() string {
	return fmt.Sprint("SpeedMmps: {", d.SpeedMmps, "} ",
		"DistMm: {", d.DistMm, "} ",
		"ShouldPlayAnimation: {", d.ShouldPlayAnimation, "}")
}

// MESSAGE TurnInPlace
type TurnInPlace struct {
	AngleRad        float32
	SpeedRadPerSec  float32
	AccelRadPerSec2 float32
	TolRad          float32
	IsAbsolute      uint8
}

func (t *TurnInPlace) Size() uint32 {
	var result uint32
	result += 4 // AngleRad float_32
	result += 4 // SpeedRadPerSec float_32
	result += 4 // AccelRadPerSec2 float_32
	result += 4 // TolRad float_32
	result += 1 // IsAbsolute uint_8
	return result
}

func (t *TurnInPlace) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &t.AngleRad); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &t.SpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &t.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &t.TolRad); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &t.IsAbsolute); err != nil {
		return err
	}
	return nil
}

func (t *TurnInPlace) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, t.AngleRad); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, t.SpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, t.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, t.TolRad); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, t.IsAbsolute); err != nil {
		return err
	}
	return nil
}

func (t *TurnInPlace) String() string {
	return fmt.Sprint("AngleRad: {", t.AngleRad, "} ",
		"SpeedRadPerSec: {", t.SpeedRadPerSec, "} ",
		"AccelRadPerSec2: {", t.AccelRadPerSec2, "} ",
		"TolRad: {", t.TolRad, "} ",
		"IsAbsolute: {", t.IsAbsolute, "}")
}

// MESSAGE SetHeadAngle
type SetHeadAngle struct {
	AngleRad          float32
	MaxSpeedRadPerSec float32
	AccelRadPerSec2   float32
	DurationSec       float32
}

func (s *SetHeadAngle) Size() uint32 {
	var result uint32
	result += 4 // AngleRad float_32
	result += 4 // MaxSpeedRadPerSec float_32
	result += 4 // AccelRadPerSec2 float_32
	result += 4 // DurationSec float_32
	return result
}

func (s *SetHeadAngle) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &s.AngleRad); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetHeadAngle) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, s.AngleRad); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetHeadAngle) String() string {
	return fmt.Sprint("AngleRad: {", s.AngleRad, "} ",
		"MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
		"AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
		"DurationSec: {", s.DurationSec, "}")
}

// MESSAGE SetLiftHeight
type SetLiftHeight struct {
	HeightMm          float32
	MaxSpeedRadPerSec float32
	AccelRadPerSec2   float32
	DurationSec       float32
}

func (s *SetLiftHeight) Size() uint32 {
	var result uint32
	result += 4 // HeightMm float_32
	result += 4 // MaxSpeedRadPerSec float_32
	result += 4 // AccelRadPerSec2 float_32
	result += 4 // DurationSec float_32
	return result
}

func (s *SetLiftHeight) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &s.HeightMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetLiftHeight) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, s.HeightMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetLiftHeight) String() string {
	return fmt.Sprint("HeightMm: {", s.HeightMm, "} ",
		"MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
		"AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
		"DurationSec: {", s.DurationSec, "}")
}

// ENUM AlignmentType
type AlignmentType uint8

const (
	AlignmentType_LIFT_FINGER AlignmentType = AlignmentType(0)
	AlignmentType_LIFT_PLATE  AlignmentType = AlignmentType_LIFT_FINGER + 1
	AlignmentType_BODY        AlignmentType = AlignmentType_LIFT_PLATE + 1
	AlignmentType_CUSTOM      AlignmentType = AlignmentType_BODY + 1
)

// MESSAGE AlignWithObject
type AlignWithObject struct {
	ObjectID             int32
	MotionProf           PathMotionProfile
	DistanceFromMarkerMm float32
	ApproachAngleRad     float32
	UseApproachAngle     bool
	UsePreDockPose       bool
	AlignmentType        AlignmentType
}

func (a *AlignWithObject) Size() uint32 {
	var result uint32
	result += 4 // ObjectID int_32
	result += a.MotionProf.Size()
	result += 4 // DistanceFromMarkerMm float_32
	result += 4 // ApproachAngleRad float_32
	result += 1 // UseApproachAngle bool
	result += 1 // UsePreDockPose bool
	result += 1 // AlignmentType AlignmentType
	return result
}

func (a *AlignWithObject) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &a.ObjectID); err != nil {
		return err
	}
	if err := a.MotionProf.Unpack(buf); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &a.DistanceFromMarkerMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &a.ApproachAngleRad); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &a.UseApproachAngle); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &a.UsePreDockPose); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &a.AlignmentType); err != nil {
		return err
	}
	return nil
}

func (a *AlignWithObject) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, a.ObjectID); err != nil {
		return err
	}
	if err := a.MotionProf.Pack(buf); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, a.DistanceFromMarkerMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, a.ApproachAngleRad); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, a.UseApproachAngle); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, a.UsePreDockPose); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, a.AlignmentType); err != nil {
		return err
	}
	return nil
}

func (a *AlignWithObject) String() string {
	return fmt.Sprint("ObjectID: {", a.ObjectID, "} ",
		"MotionProf: {", a.MotionProf, "} ",
		"DistanceFromMarkerMm: {", a.DistanceFromMarkerMm, "} ",
		"ApproachAngleRad: {", a.ApproachAngleRad, "} ",
		"UseApproachAngle: {", a.UseApproachAngle, "} ",
		"UsePreDockPose: {", a.UsePreDockPose, "} ",
		"AlignmentType: {", a.AlignmentType, "}")
}

// MESSAGE SetLiftAngle
type SetLiftAngle struct {
	AngleRad          float32
	MaxSpeedRadPerSec float32
	AccelRadPerSec2   float32
	DurationSec       float32
}

func (s *SetLiftAngle) Size() uint32 {
	var result uint32
	result += 4 // AngleRad float_32
	result += 4 // MaxSpeedRadPerSec float_32
	result += 4 // AccelRadPerSec2 float_32
	result += 4 // DurationSec float_32
	return result
}

func (s *SetLiftAngle) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &s.AngleRad); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetLiftAngle) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, s.AngleRad); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
		return err
	}
	return nil
}

func (s *SetLiftAngle) String() string {
	return fmt.Sprint("AngleRad: {", s.AngleRad, "} ",
		"MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
		"AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
		"DurationSec: {", s.DurationSec, "}")
}

// MESSAGE DeleteCustomMarkerObjects
type DeleteCustomMarkerObjects struct {
}

func (d *DeleteCustomMarkerObjects) Size() uint32 {
	return 0
}

func (d *DeleteCustomMarkerObjects) Unpack(buf *bytes.Buffer) error {
	return nil
}

func (d *DeleteCustomMarkerObjects) Pack(buf *bytes.Buffer) error {
	return nil
}

func (d *DeleteCustomMarkerObjects) String() string {
	return ""
}

// MESSAGE DeleteFixedCustomObjects
type DeleteFixedCustomObjects struct {
}

func (d *DeleteFixedCustomObjects) Size() uint32 {
	return 0
}

func (d *DeleteFixedCustomObjects) Unpack(buf *bytes.Buffer) error {
	return nil
}

func (d *DeleteFixedCustomObjects) Pack(buf *bytes.Buffer) error {
	return nil
}

func (d *DeleteFixedCustomObjects) String() string {
	return ""
}

// MESSAGE UndefineAllCustomMarkerObjects
type UndefineAllCustomMarkerObjects struct {
}

func (u *UndefineAllCustomMarkerObjects) Size() uint32 {
	return 0
}

func (u *UndefineAllCustomMarkerObjects) Unpack(buf *bytes.Buffer) error {
	return nil
}

func (u *UndefineAllCustomMarkerObjects) Pack(buf *bytes.Buffer) error {
	return nil
}

func (u *UndefineAllCustomMarkerObjects) String() string {
	return ""
}

// MESSAGE CreateFixedCustomObject
type CreateFixedCustomObject struct {
	Pose    PoseStruct3d
	XSizeMm float32
	YSizeMm float32
	ZSizeMm float32
}

func (c *CreateFixedCustomObject) Size() uint32 {
	var result uint32
	result += c.Pose.Size()
	result += 4 // XSizeMm float_32
	result += 4 // YSizeMm float_32
	result += 4 // ZSizeMm float_32
	return result
}

func (c *CreateFixedCustomObject) Unpack(buf *bytes.Buffer) error {
	if err := c.Pose.Unpack(buf); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &c.XSizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &c.YSizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &c.ZSizeMm); err != nil {
		return err
	}
	return nil
}

func (c *CreateFixedCustomObject) Pack(buf *bytes.Buffer) error {
	if err := c.Pose.Pack(buf); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, c.XSizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, c.YSizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, c.ZSizeMm); err != nil {
		return err
	}
	return nil
}

func (c *CreateFixedCustomObject) String() string {
	return fmt.Sprint("Pose: {", c.Pose, "} ",
		"XSizeMm: {", c.XSizeMm, "} ",
		"YSizeMm: {", c.YSizeMm, "} ",
		"ZSizeMm: {", c.ZSizeMm, "}")
}

// ENUM CustomObjectMarker
type CustomObjectMarker int16

const (
	CustomObjectMarker_Circles2 CustomObjectMarker = iota
	CustomObjectMarker_Circles3
	CustomObjectMarker_Circles4
	CustomObjectMarker_Circles5
	CustomObjectMarker_Diamonds2
	CustomObjectMarker_Diamonds3
	CustomObjectMarker_Diamonds4
	CustomObjectMarker_Diamonds5
	CustomObjectMarker_Hexagons2
	CustomObjectMarker_Hexagons3
	CustomObjectMarker_Hexagons4
	CustomObjectMarker_Hexagons5
	CustomObjectMarker_Triangles2
	CustomObjectMarker_Triangles3
	CustomObjectMarker_Triangles4
	CustomObjectMarker_Triangles5
	CustomObjectMarker_Count
)

// MESSAGE DefineCustomBox
type DefineCustomBox struct {
	CustomType     ObjectType
	MarkerFront    CustomObjectMarker
	MarkerBack     CustomObjectMarker
	MarkerTop      CustomObjectMarker
	MarkerBottom   CustomObjectMarker
	MarkerLeft     CustomObjectMarker
	MarkerRight    CustomObjectMarker
	XSizeMm        float32
	YSizeMm        float32
	ZSizeMm        float32
	MarkerWidthMm  float32
	MarkerHeightMm float32
	IsUnique       bool
}

func (d *DefineCustomBox) Size() uint32 {
	var result uint32
	result += 4 // CustomType ObjectType
	result += 2 // MarkerFront CustomObjectMarker
	result += 2 // MarkerBack CustomObjectMarker
	result += 2 // MarkerTop CustomObjectMarker
	result += 2 // MarkerBottom CustomObjectMarker
	result += 2 // MarkerLeft CustomObjectMarker
	result += 2 // MarkerRight CustomObjectMarker
	result += 4 // XSizeMm float_32
	result += 4 // YSizeMm float_32
	result += 4 // ZSizeMm float_32
	result += 4 // MarkerWidthMm float_32
	result += 4 // MarkerHeightMm float_32
	result += 1 // IsUnique bool
	return result
}

func (d *DefineCustomBox) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerFront); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerBack); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerTop); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerBottom); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerLeft); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerRight); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.XSizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.YSizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.ZSizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomBox) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerFront); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerBack); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerTop); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerBottom); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerLeft); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerRight); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.XSizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.YSizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.ZSizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomBox) String() string {
	return fmt.Sprint("CustomType: {", d.CustomType, "} ",
		"MarkerFront: {", d.MarkerFront, "} ",
		"MarkerBack: {", d.MarkerBack, "} ",
		"MarkerTop: {", d.MarkerTop, "} ",
		"MarkerBottom: {", d.MarkerBottom, "} ",
		"MarkerLeft: {", d.MarkerLeft, "} ",
		"MarkerRight: {", d.MarkerRight, "} ",
		"XSizeMm: {", d.XSizeMm, "} ",
		"YSizeMm: {", d.YSizeMm, "} ",
		"ZSizeMm: {", d.ZSizeMm, "} ",
		"MarkerWidthMm: {", d.MarkerWidthMm, "} ",
		"MarkerHeightMm: {", d.MarkerHeightMm, "} ",
		"IsUnique: {", d.IsUnique, "}")
}

// MESSAGE DefineCustomCube
type DefineCustomCube struct {
	CustomType     ObjectType
	Marker         CustomObjectMarker
	SizeMm         float32
	MarkerWidthMm  float32
	MarkerHeightMm float32
	IsUnique       bool
}

func (d *DefineCustomCube) Size() uint32 {
	var result uint32
	result += 4 // CustomType ObjectType
	result += 2 // Marker CustomObjectMarker
	result += 4 // SizeMm float_32
	result += 4 // MarkerWidthMm float_32
	result += 4 // MarkerHeightMm float_32
	result += 1 // IsUnique bool
	return result
}

func (d *DefineCustomCube) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.Marker); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.SizeMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomCube) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.Marker); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.SizeMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomCube) String() string {
	return fmt.Sprint("CustomType: {", d.CustomType, "} ",
		"Marker: {", d.Marker, "} ",
		"SizeMm: {", d.SizeMm, "} ",
		"MarkerWidthMm: {", d.MarkerWidthMm, "} ",
		"MarkerHeightMm: {", d.MarkerHeightMm, "} ",
		"IsUnique: {", d.IsUnique, "}")
}

// MESSAGE DefineCustomWall
type DefineCustomWall struct {
	CustomType     ObjectType
	Marker         CustomObjectMarker
	WidthMm        float32
	HeightMm       float32
	MarkerWidthMm  float32
	MarkerHeightMm float32
	IsUnique       bool
}

func (d *DefineCustomWall) Size() uint32 {
	var result uint32
	result += 4 // CustomType ObjectType
	result += 2 // Marker CustomObjectMarker
	result += 4 // WidthMm float_32
	result += 4 // HeightMm float_32
	result += 4 // MarkerWidthMm float_32
	result += 4 // MarkerHeightMm float_32
	result += 1 // IsUnique bool
	return result
}

func (d *DefineCustomWall) Unpack(buf *bytes.Buffer) error {
	if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.Marker); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.WidthMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.HeightMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomWall) Pack(buf *bytes.Buffer) error {
	if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.Marker); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.WidthMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.HeightMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
		return err
	}
	if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
		return err
	}
	return nil
}

func (d *DefineCustomWall) String() string {
	return fmt.Sprint("CustomType: {", d.CustomType, "} ",
		"Marker: {", d.Marker, "} ",
		"WidthMm: {", d.WidthMm, "} ",
		"HeightMm: {", d.HeightMm, "} ",
		"MarkerWidthMm: {", d.MarkerWidthMm, "} ",
		"MarkerHeightMm: {", d.MarkerHeightMm, "} ",
		"IsUnique: {", d.IsUnique, "}")
}

// MESSAGE SetMemoryMapBroadcastFrequency_sec
type SetMemoryMapBroadcastFrequencySec = SetMemoryMapBroadcastFrequency_sec

type SetMemoryMapBroadcastFrequency_sec struct {
	Frequency float32
}

func (s *SetMemoryMapBroadcastFrequency_sec) Size() uint32 {
	var result uint32
	result += 4 // Frequency float_32
	return result
}

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

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

func (s *SetMemoryMapBroadcastFrequency_sec) String() string {
	return fmt.Sprint("Frequency: {", s.Frequency, "}")
}

// UNION MessageExternalToRobot
type MessageExternalToRobotTag uint8

const (
	MessageExternalToRobotTag_UiDeviceConnectionWrongVersion    MessageExternalToRobotTag = 0x0  // 0
	MessageExternalToRobotTag_MoveHead                          MessageExternalToRobotTag = 0x3  // 3
	MessageExternalToRobotTag_MoveLift                          MessageExternalToRobotTag = 0x4  // 4
	MessageExternalToRobotTag_DriveArc                          MessageExternalToRobotTag = 0x5  // 5
	MessageExternalToRobotTag_RobotHistoryRequest               MessageExternalToRobotTag = 0x6  // 6
	MessageExternalToRobotTag_DisplayFaceImageRGBChunk          MessageExternalToRobotTag = 0x8  // 8
	MessageExternalToRobotTag_AppIntent                         MessageExternalToRobotTag = 0x9  // 9
	MessageExternalToRobotTag_CancelFaceEnrollment              MessageExternalToRobotTag = 0xa  // 10
	MessageExternalToRobotTag_RequestEnrolledNames              MessageExternalToRobotTag = 0xb  // 11
	MessageExternalToRobotTag_UpdateEnrolledFaceByID            MessageExternalToRobotTag = 0xc  // 12
	MessageExternalToRobotTag_EraseEnrolledFaceByID             MessageExternalToRobotTag = 0xd  // 13
	MessageExternalToRobotTag_EraseAllEnrolledFaces             MessageExternalToRobotTag = 0xe  // 14
	MessageExternalToRobotTag_SetFaceToEnroll                   MessageExternalToRobotTag = 0xf  // 15
	MessageExternalToRobotTag_EnableVisionMode                  MessageExternalToRobotTag = 0x10 // 16
	MessageExternalToRobotTag_GotoPose                          MessageExternalToRobotTag = 0x12 // 18
	MessageExternalToRobotTag_DriveStraight                     MessageExternalToRobotTag = 0x13 // 19
	MessageExternalToRobotTag_TurnInPlace                       MessageExternalToRobotTag = 0x14 // 20
	MessageExternalToRobotTag_SetHeadAngle                      MessageExternalToRobotTag = 0x15 // 21
	MessageExternalToRobotTag_SetLiftHeight                     MessageExternalToRobotTag = 0x16 // 22
	MessageExternalToRobotTag_AlignWithObject                   MessageExternalToRobotTag = 0x18 // 24
	MessageExternalToRobotTag_SetLiftAngle                      MessageExternalToRobotTag = 0x19 // 25
	MessageExternalToRobotTag_DeleteCustomMarkerObjects         MessageExternalToRobotTag = 0x1a // 26
	MessageExternalToRobotTag_DeleteFixedCustomObjects          MessageExternalToRobotTag = 0x1b // 27
	MessageExternalToRobotTag_UndefineAllCustomMarkerObjects    MessageExternalToRobotTag = 0x1c // 28
	MessageExternalToRobotTag_CreateFixedCustomObject           MessageExternalToRobotTag = 0x1d // 29
	MessageExternalToRobotTag_DefineCustomBox                   MessageExternalToRobotTag = 0x1e // 30
	MessageExternalToRobotTag_DefineCustomCube                  MessageExternalToRobotTag = 0x1f // 31
	MessageExternalToRobotTag_DefineCustomWall                  MessageExternalToRobotTag = 0x20 // 32
	MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec MessageExternalToRobotTag = 0x21 // 33
	MessageExternalToRobotTag_INVALID                           MessageExternalToRobotTag = 255
)

type MessageExternalToRobot struct {
	tag   *MessageExternalToRobotTag
	value clad.Struct
}

func (m *MessageExternalToRobot) Tag() MessageExternalToRobotTag {
	if m.tag == nil {
		return MessageExternalToRobotTag_INVALID
	}
	return *m.tag
}

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

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

func (m *MessageExternalToRobot) unpackStruct(tag MessageExternalToRobotTag, buf *bytes.Buffer) (clad.Struct, error) {
	switch tag {
	case MessageExternalToRobotTag_UiDeviceConnectionWrongVersion:
		var ret UiDeviceConnectionWrongVersion
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_MoveHead:
		var ret MoveHead
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_MoveLift:
		var ret MoveLift
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DriveArc:
		var ret DriveArc
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_RobotHistoryRequest:
		var ret RobotHistoryRequest
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DisplayFaceImageRGBChunk:
		var ret DisplayFaceImageRGBChunk
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_AppIntent:
		var ret AppIntent
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_CancelFaceEnrollment:
		var ret CancelFaceEnrollment
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_RequestEnrolledNames:
		var ret RequestEnrolledNames
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_UpdateEnrolledFaceByID:
		var ret UpdateEnrolledFaceByID
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_EraseEnrolledFaceByID:
		var ret EraseEnrolledFaceByID
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_EraseAllEnrolledFaces:
		var ret EraseAllEnrolledFaces
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_SetFaceToEnroll:
		var ret SetFaceToEnroll
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_EnableVisionMode:
		var ret EnableVisionMode
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_GotoPose:
		var ret GotoPose
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DriveStraight:
		var ret DriveStraight
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_TurnInPlace:
		var ret TurnInPlace
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_SetHeadAngle:
		var ret SetHeadAngle
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_SetLiftHeight:
		var ret SetLiftHeight
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_AlignWithObject:
		var ret AlignWithObject
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_SetLiftAngle:
		var ret SetLiftAngle
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DeleteCustomMarkerObjects:
		var ret DeleteCustomMarkerObjects
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DeleteFixedCustomObjects:
		var ret DeleteFixedCustomObjects
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_UndefineAllCustomMarkerObjects:
		var ret UndefineAllCustomMarkerObjects
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_CreateFixedCustomObject:
		var ret CreateFixedCustomObject
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DefineCustomBox:
		var ret DefineCustomBox
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DefineCustomCube:
		var ret DefineCustomCube
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_DefineCustomWall:
		var ret DefineCustomWall
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	case MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec:
		var ret SetMemoryMapBroadcastFrequency_sec
		if err := ret.Unpack(buf); err != nil {
			return nil, err
		}
		return &ret, nil
	default:
		return nil, errors.New("invalid tag to unpackStruct")
	}
}

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

func (t MessageExternalToRobotTag) String() string {
	switch t {
	case MessageExternalToRobotTag_UiDeviceConnectionWrongVersion:
		return "UiDeviceConnectionWrongVersion"
	case MessageExternalToRobotTag_MoveHead:
		return "MoveHead"
	case MessageExternalToRobotTag_MoveLift:
		return "MoveLift"
	case MessageExternalToRobotTag_DriveArc:
		return "DriveArc"
	case MessageExternalToRobotTag_RobotHistoryRequest:
		return "RobotHistoryRequest"
	case MessageExternalToRobotTag_DisplayFaceImageRGBChunk:
		return "DisplayFaceImageRGBChunk"
	case MessageExternalToRobotTag_AppIntent:
		return "AppIntent"
	case MessageExternalToRobotTag_CancelFaceEnrollment:
		return "CancelFaceEnrollment"
	case MessageExternalToRobotTag_RequestEnrolledNames:
		return "RequestEnrolledNames"
	case MessageExternalToRobotTag_UpdateEnrolledFaceByID:
		return "UpdateEnrolledFaceByID"
	case MessageExternalToRobotTag_EraseEnrolledFaceByID:
		return "EraseEnrolledFaceByID"
	case MessageExternalToRobotTag_EraseAllEnrolledFaces:
		return "EraseAllEnrolledFaces"
	case MessageExternalToRobotTag_SetFaceToEnroll:
		return "SetFaceToEnroll"
	case MessageExternalToRobotTag_EnableVisionMode:
		return "EnableVisionMode"
	case MessageExternalToRobotTag_GotoPose:
		return "GotoPose"
	case MessageExternalToRobotTag_DriveStraight:
		return "DriveStraight"
	case MessageExternalToRobotTag_TurnInPlace:
		return "TurnInPlace"
	case MessageExternalToRobotTag_SetHeadAngle:
		return "SetHeadAngle"
	case MessageExternalToRobotTag_SetLiftHeight:
		return "SetLiftHeight"
	case MessageExternalToRobotTag_AlignWithObject:
		return "AlignWithObject"
	case MessageExternalToRobotTag_SetLiftAngle:
		return "SetLiftAngle"
	case MessageExternalToRobotTag_DeleteCustomMarkerObjects:
		return "DeleteCustomMarkerObjects"
	case MessageExternalToRobotTag_DeleteFixedCustomObjects:
		return "DeleteFixedCustomObjects"
	case MessageExternalToRobotTag_UndefineAllCustomMarkerObjects:
		return "UndefineAllCustomMarkerObjects"
	case MessageExternalToRobotTag_CreateFixedCustomObject:
		return "CreateFixedCustomObject"
	case MessageExternalToRobotTag_DefineCustomBox:
		return "DefineCustomBox"
	case MessageExternalToRobotTag_DefineCustomCube:
		return "DefineCustomCube"
	case MessageExternalToRobotTag_DefineCustomWall:
		return "DefineCustomWall"
	case MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec:
		return "SetMemoryMapBroadcastFrequencySec"
	default:
		return "INVALID"
	}
}

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

func (m *MessageExternalToRobot) GetUiDeviceConnectionWrongVersion() *UiDeviceConnectionWrongVersion {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_UiDeviceConnectionWrongVersion {
		return nil
	}
	return m.value.(*UiDeviceConnectionWrongVersion)
}

func (m *MessageExternalToRobot) SetUiDeviceConnectionWrongVersion(value *UiDeviceConnectionWrongVersion) {
	newTag := MessageExternalToRobotTag_UiDeviceConnectionWrongVersion
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithUiDeviceConnectionWrongVersion(value *UiDeviceConnectionWrongVersion) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetUiDeviceConnectionWrongVersion(value)
	return &ret
}

func (m *MessageExternalToRobot) GetMoveHead() *MoveHead {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_MoveHead {
		return nil
	}
	return m.value.(*MoveHead)
}

func (m *MessageExternalToRobot) SetMoveHead(value *MoveHead) {
	newTag := MessageExternalToRobotTag_MoveHead
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithMoveHead(value *MoveHead) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetMoveHead(value)
	return &ret
}

func (m *MessageExternalToRobot) GetMoveLift() *MoveLift {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_MoveLift {
		return nil
	}
	return m.value.(*MoveLift)
}

func (m *MessageExternalToRobot) SetMoveLift(value *MoveLift) {
	newTag := MessageExternalToRobotTag_MoveLift
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithMoveLift(value *MoveLift) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetMoveLift(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDriveArc() *DriveArc {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DriveArc {
		return nil
	}
	return m.value.(*DriveArc)
}

func (m *MessageExternalToRobot) SetDriveArc(value *DriveArc) {
	newTag := MessageExternalToRobotTag_DriveArc
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDriveArc(value *DriveArc) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDriveArc(value)
	return &ret
}

func (m *MessageExternalToRobot) GetRobotHistoryRequest() *RobotHistoryRequest {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_RobotHistoryRequest {
		return nil
	}
	return m.value.(*RobotHistoryRequest)
}

func (m *MessageExternalToRobot) SetRobotHistoryRequest(value *RobotHistoryRequest) {
	newTag := MessageExternalToRobotTag_RobotHistoryRequest
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithRobotHistoryRequest(value *RobotHistoryRequest) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetRobotHistoryRequest(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDisplayFaceImageRGBChunk() *DisplayFaceImageRGBChunk {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DisplayFaceImageRGBChunk {
		return nil
	}
	return m.value.(*DisplayFaceImageRGBChunk)
}

func (m *MessageExternalToRobot) SetDisplayFaceImageRGBChunk(value *DisplayFaceImageRGBChunk) {
	newTag := MessageExternalToRobotTag_DisplayFaceImageRGBChunk
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDisplayFaceImageRGBChunk(value *DisplayFaceImageRGBChunk) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDisplayFaceImageRGBChunk(value)
	return &ret
}

func (m *MessageExternalToRobot) GetAppIntent() *AppIntent {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_AppIntent {
		return nil
	}
	return m.value.(*AppIntent)
}

func (m *MessageExternalToRobot) SetAppIntent(value *AppIntent) {
	newTag := MessageExternalToRobotTag_AppIntent
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithAppIntent(value *AppIntent) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetAppIntent(value)
	return &ret
}

func (m *MessageExternalToRobot) GetCancelFaceEnrollment() *CancelFaceEnrollment {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_CancelFaceEnrollment {
		return nil
	}
	return m.value.(*CancelFaceEnrollment)
}

func (m *MessageExternalToRobot) SetCancelFaceEnrollment(value *CancelFaceEnrollment) {
	newTag := MessageExternalToRobotTag_CancelFaceEnrollment
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithCancelFaceEnrollment(value *CancelFaceEnrollment) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetCancelFaceEnrollment(value)
	return &ret
}

func (m *MessageExternalToRobot) GetRequestEnrolledNames() *RequestEnrolledNames {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_RequestEnrolledNames {
		return nil
	}
	return m.value.(*RequestEnrolledNames)
}

func (m *MessageExternalToRobot) SetRequestEnrolledNames(value *RequestEnrolledNames) {
	newTag := MessageExternalToRobotTag_RequestEnrolledNames
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithRequestEnrolledNames(value *RequestEnrolledNames) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetRequestEnrolledNames(value)
	return &ret
}

func (m *MessageExternalToRobot) GetUpdateEnrolledFaceByID() *UpdateEnrolledFaceByID {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_UpdateEnrolledFaceByID {
		return nil
	}
	return m.value.(*UpdateEnrolledFaceByID)
}

func (m *MessageExternalToRobot) SetUpdateEnrolledFaceByID(value *UpdateEnrolledFaceByID) {
	newTag := MessageExternalToRobotTag_UpdateEnrolledFaceByID
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithUpdateEnrolledFaceByID(value *UpdateEnrolledFaceByID) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetUpdateEnrolledFaceByID(value)
	return &ret
}

func (m *MessageExternalToRobot) GetEraseEnrolledFaceByID() *EraseEnrolledFaceByID {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_EraseEnrolledFaceByID {
		return nil
	}
	return m.value.(*EraseEnrolledFaceByID)
}

func (m *MessageExternalToRobot) SetEraseEnrolledFaceByID(value *EraseEnrolledFaceByID) {
	newTag := MessageExternalToRobotTag_EraseEnrolledFaceByID
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithEraseEnrolledFaceByID(value *EraseEnrolledFaceByID) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetEraseEnrolledFaceByID(value)
	return &ret
}

func (m *MessageExternalToRobot) GetEraseAllEnrolledFaces() *EraseAllEnrolledFaces {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_EraseAllEnrolledFaces {
		return nil
	}
	return m.value.(*EraseAllEnrolledFaces)
}

func (m *MessageExternalToRobot) SetEraseAllEnrolledFaces(value *EraseAllEnrolledFaces) {
	newTag := MessageExternalToRobotTag_EraseAllEnrolledFaces
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithEraseAllEnrolledFaces(value *EraseAllEnrolledFaces) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetEraseAllEnrolledFaces(value)
	return &ret
}

func (m *MessageExternalToRobot) GetSetFaceToEnroll() *SetFaceToEnroll {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetFaceToEnroll {
		return nil
	}
	return m.value.(*SetFaceToEnroll)
}

func (m *MessageExternalToRobot) SetSetFaceToEnroll(value *SetFaceToEnroll) {
	newTag := MessageExternalToRobotTag_SetFaceToEnroll
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithSetFaceToEnroll(value *SetFaceToEnroll) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetSetFaceToEnroll(value)
	return &ret
}

func (m *MessageExternalToRobot) GetEnableVisionMode() *EnableVisionMode {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_EnableVisionMode {
		return nil
	}
	return m.value.(*EnableVisionMode)
}

func (m *MessageExternalToRobot) SetEnableVisionMode(value *EnableVisionMode) {
	newTag := MessageExternalToRobotTag_EnableVisionMode
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithEnableVisionMode(value *EnableVisionMode) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetEnableVisionMode(value)
	return &ret
}

func (m *MessageExternalToRobot) GetGotoPose() *GotoPose {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_GotoPose {
		return nil
	}
	return m.value.(*GotoPose)
}

func (m *MessageExternalToRobot) SetGotoPose(value *GotoPose) {
	newTag := MessageExternalToRobotTag_GotoPose
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithGotoPose(value *GotoPose) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetGotoPose(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDriveStraight() *DriveStraight {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DriveStraight {
		return nil
	}
	return m.value.(*DriveStraight)
}

func (m *MessageExternalToRobot) SetDriveStraight(value *DriveStraight) {
	newTag := MessageExternalToRobotTag_DriveStraight
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDriveStraight(value *DriveStraight) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDriveStraight(value)
	return &ret
}

func (m *MessageExternalToRobot) GetTurnInPlace() *TurnInPlace {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_TurnInPlace {
		return nil
	}
	return m.value.(*TurnInPlace)
}

func (m *MessageExternalToRobot) SetTurnInPlace(value *TurnInPlace) {
	newTag := MessageExternalToRobotTag_TurnInPlace
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithTurnInPlace(value *TurnInPlace) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetTurnInPlace(value)
	return &ret
}

func (m *MessageExternalToRobot) GetSetHeadAngle() *SetHeadAngle {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetHeadAngle {
		return nil
	}
	return m.value.(*SetHeadAngle)
}

func (m *MessageExternalToRobot) SetSetHeadAngle(value *SetHeadAngle) {
	newTag := MessageExternalToRobotTag_SetHeadAngle
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithSetHeadAngle(value *SetHeadAngle) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetSetHeadAngle(value)
	return &ret
}

func (m *MessageExternalToRobot) GetSetLiftHeight() *SetLiftHeight {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetLiftHeight {
		return nil
	}
	return m.value.(*SetLiftHeight)
}

func (m *MessageExternalToRobot) SetSetLiftHeight(value *SetLiftHeight) {
	newTag := MessageExternalToRobotTag_SetLiftHeight
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithSetLiftHeight(value *SetLiftHeight) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetSetLiftHeight(value)
	return &ret
}

func (m *MessageExternalToRobot) GetAlignWithObject() *AlignWithObject {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_AlignWithObject {
		return nil
	}
	return m.value.(*AlignWithObject)
}

func (m *MessageExternalToRobot) SetAlignWithObject(value *AlignWithObject) {
	newTag := MessageExternalToRobotTag_AlignWithObject
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithAlignWithObject(value *AlignWithObject) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetAlignWithObject(value)
	return &ret
}

func (m *MessageExternalToRobot) GetSetLiftAngle() *SetLiftAngle {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetLiftAngle {
		return nil
	}
	return m.value.(*SetLiftAngle)
}

func (m *MessageExternalToRobot) SetSetLiftAngle(value *SetLiftAngle) {
	newTag := MessageExternalToRobotTag_SetLiftAngle
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithSetLiftAngle(value *SetLiftAngle) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetSetLiftAngle(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDeleteCustomMarkerObjects() *DeleteCustomMarkerObjects {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DeleteCustomMarkerObjects {
		return nil
	}
	return m.value.(*DeleteCustomMarkerObjects)
}

func (m *MessageExternalToRobot) SetDeleteCustomMarkerObjects(value *DeleteCustomMarkerObjects) {
	newTag := MessageExternalToRobotTag_DeleteCustomMarkerObjects
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDeleteCustomMarkerObjects(value *DeleteCustomMarkerObjects) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDeleteCustomMarkerObjects(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDeleteFixedCustomObjects() *DeleteFixedCustomObjects {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DeleteFixedCustomObjects {
		return nil
	}
	return m.value.(*DeleteFixedCustomObjects)
}

func (m *MessageExternalToRobot) SetDeleteFixedCustomObjects(value *DeleteFixedCustomObjects) {
	newTag := MessageExternalToRobotTag_DeleteFixedCustomObjects
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDeleteFixedCustomObjects(value *DeleteFixedCustomObjects) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDeleteFixedCustomObjects(value)
	return &ret
}

func (m *MessageExternalToRobot) GetUndefineAllCustomMarkerObjects() *UndefineAllCustomMarkerObjects {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_UndefineAllCustomMarkerObjects {
		return nil
	}
	return m.value.(*UndefineAllCustomMarkerObjects)
}

func (m *MessageExternalToRobot) SetUndefineAllCustomMarkerObjects(value *UndefineAllCustomMarkerObjects) {
	newTag := MessageExternalToRobotTag_UndefineAllCustomMarkerObjects
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithUndefineAllCustomMarkerObjects(value *UndefineAllCustomMarkerObjects) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetUndefineAllCustomMarkerObjects(value)
	return &ret
}

func (m *MessageExternalToRobot) GetCreateFixedCustomObject() *CreateFixedCustomObject {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_CreateFixedCustomObject {
		return nil
	}
	return m.value.(*CreateFixedCustomObject)
}

func (m *MessageExternalToRobot) SetCreateFixedCustomObject(value *CreateFixedCustomObject) {
	newTag := MessageExternalToRobotTag_CreateFixedCustomObject
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithCreateFixedCustomObject(value *CreateFixedCustomObject) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetCreateFixedCustomObject(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomBox() *DefineCustomBox {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomBox {
		return nil
	}
	return m.value.(*DefineCustomBox)
}

func (m *MessageExternalToRobot) SetDefineCustomBox(value *DefineCustomBox) {
	newTag := MessageExternalToRobotTag_DefineCustomBox
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDefineCustomBox(value *DefineCustomBox) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDefineCustomBox(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomCube() *DefineCustomCube {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomCube {
		return nil
	}
	return m.value.(*DefineCustomCube)
}

func (m *MessageExternalToRobot) SetDefineCustomCube(value *DefineCustomCube) {
	newTag := MessageExternalToRobotTag_DefineCustomCube
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDefineCustomCube(value *DefineCustomCube) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDefineCustomCube(value)
	return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomWall() *DefineCustomWall {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomWall {
		return nil
	}
	return m.value.(*DefineCustomWall)
}

func (m *MessageExternalToRobot) SetDefineCustomWall(value *DefineCustomWall) {
	newTag := MessageExternalToRobotTag_DefineCustomWall
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithDefineCustomWall(value *DefineCustomWall) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetDefineCustomWall(value)
	return &ret
}

func (m *MessageExternalToRobot) GetSetMemoryMapBroadcastFrequencySec() *SetMemoryMapBroadcastFrequency_sec {
	if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec {
		return nil
	}
	return m.value.(*SetMemoryMapBroadcastFrequency_sec)
}

func (m *MessageExternalToRobot) SetSetMemoryMapBroadcastFrequencySec(value *SetMemoryMapBroadcastFrequency_sec) {
	newTag := MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec
	m.tag = &newTag
	m.value = value
}

func NewMessageExternalToRobotWithSetMemoryMapBroadcastFrequencySec(value *SetMemoryMapBroadcastFrequency_sec) *MessageExternalToRobot {
	var ret MessageExternalToRobot
	ret.SetSetMemoryMapBroadcastFrequencySec(value)
	return &ret
}