// Autogenerated C# message buffer code.
// Source: clad/externalInterface/messageGameToEngine.clad
// Full command line: victor-clad/tools/message-buffers/emitters/CSharp_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladCSharp clad/externalInterface/messageGameToEngine.clad

namespace Anki {

namespace Vector {

namespace ExternalInterface {

public partial class UiDeviceConnectionWrongVersion
{
  private byte _reserved; // uint_8
  private Anki.Vector.UiConnectionType _connectionType; // UiConnectionType
  private uint _deviceID; // uint_32
  private string _buildVersion; // string[uint_8]

  public byte reserved { get { return _reserved; } set { _reserved = value; } }

  public Anki.Vector.UiConnectionType connectionType { get { return _connectionType; } set { _connectionType = value; } }

  public uint deviceID { get { return _deviceID; } set { _deviceID = value; } }

  public string buildVersion
  {
    get {
      return _buildVersion;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("buildVersion string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _buildVersion = value;
    }
  }


  /**** Constructors ****/

  public UiDeviceConnectionWrongVersion()
  {
  }

  public UiDeviceConnectionWrongVersion(byte reserved,
    Anki.Vector.UiConnectionType connectionType,
    uint deviceID,
    string buildVersion)
  {
    this.reserved = reserved;
    this.connectionType = connectionType;
    this.deviceID = deviceID;
    this.buildVersion = buildVersion;
  }

  public UiDeviceConnectionWrongVersion(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public UiDeviceConnectionWrongVersion(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public UiDeviceConnectionWrongVersion Initialize(byte reserved,
    Anki.Vector.UiConnectionType connectionType,
    uint deviceID,
    string buildVersion)
  {
    this.reserved = reserved;
    this.connectionType = connectionType;
    this.deviceID = deviceID;
    this.buildVersion = buildVersion;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _reserved = reader.ReadByte();
    _connectionType = (Anki.Vector.UiConnectionType)reader.ReadByte();
    _deviceID = reader.ReadUInt32();
    int _buildVersion_length = (int)reader.ReadByte();
    byte[] _buildVersion_bytes = reader.ReadBytes(_buildVersion_length);
    _buildVersion = System.Text.Encoding.UTF8.GetString(_buildVersion_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_reserved);
    writer.Write((byte)_connectionType);
    writer.Write((uint)_deviceID);
    if (_buildVersion != null) {
      byte[] _buildVersion_bytes = System.Text.Encoding.UTF8.GetBytes(_buildVersion);
      writer.Write((byte)_buildVersion_bytes.Length);
      writer.Write(_buildVersion_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      result += 1; // UiConnectionType
      result += 4; // uint_32
      result += 1; // uint_8
      if (buildVersion != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(buildVersion);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(UiDeviceConnectionWrongVersion a, UiDeviceConnectionWrongVersion b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(UiDeviceConnectionWrongVersion a, UiDeviceConnectionWrongVersion b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as UiDeviceConnectionWrongVersion);
  }

  public bool Equals(UiDeviceConnectionWrongVersion p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._reserved.Equals(p._reserved)
      && this._connectionType.Equals(p._connectionType)
      && this._deviceID.Equals(p._deviceID)
      && this._buildVersion.Equals(p._buildVersion);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._reserved.GetHashCode();
      hash = hash * 23 + this._connectionType.GetHashCode();
      hash = hash * 23 + this._deviceID.GetHashCode();
      return hash;
    }
  }
}

public partial class ConnectToUiDevice
{
  private Anki.Vector.UiConnectionType _connectionType; // UiConnectionType
  private byte _deviceID; // uint_8

  public Anki.Vector.UiConnectionType connectionType { get { return _connectionType; } set { _connectionType = value; } }

  public byte deviceID { get { return _deviceID; } set { _deviceID = value; } }


  /**** Constructors ****/

  public ConnectToUiDevice()
  {
  }

  public ConnectToUiDevice(Anki.Vector.UiConnectionType connectionType,
    byte deviceID)
  {
    this.connectionType = connectionType;
    this.deviceID = deviceID;
  }

  public ConnectToUiDevice(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ConnectToUiDevice(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ConnectToUiDevice Initialize(Anki.Vector.UiConnectionType connectionType,
    byte deviceID)
  {
    this.connectionType = connectionType;
    this.deviceID = deviceID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _connectionType = (Anki.Vector.UiConnectionType)reader.ReadByte();
    _deviceID = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_connectionType);
    writer.Write((byte)_deviceID);
  }

  public int Size
  {
    get {
      return 2;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ConnectToUiDevice a, ConnectToUiDevice b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ConnectToUiDevice a, ConnectToUiDevice b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ConnectToUiDevice);
  }

  public bool Equals(ConnectToUiDevice p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._connectionType.Equals(p._connectionType)
      && this._deviceID.Equals(p._deviceID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._connectionType.GetHashCode();
      hash = hash * 23 + this._deviceID.GetHashCode();
      return hash;
    }
  }
}

public partial class DisconnectFromUiDevice
{
  private Anki.Vector.UiConnectionType _connectionType; // UiConnectionType
  private byte _deviceID; // uint_8

  public Anki.Vector.UiConnectionType connectionType { get { return _connectionType; } set { _connectionType = value; } }

  public byte deviceID { get { return _deviceID; } set { _deviceID = value; } }


  /**** Constructors ****/

  public DisconnectFromUiDevice()
  {
  }

  public DisconnectFromUiDevice(Anki.Vector.UiConnectionType connectionType,
    byte deviceID)
  {
    this.connectionType = connectionType;
    this.deviceID = deviceID;
  }

  public DisconnectFromUiDevice(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DisconnectFromUiDevice(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DisconnectFromUiDevice Initialize(Anki.Vector.UiConnectionType connectionType,
    byte deviceID)
  {
    this.connectionType = connectionType;
    this.deviceID = deviceID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _connectionType = (Anki.Vector.UiConnectionType)reader.ReadByte();
    _deviceID = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_connectionType);
    writer.Write((byte)_deviceID);
  }

  public int Size
  {
    get {
      return 2;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DisconnectFromUiDevice a, DisconnectFromUiDevice b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DisconnectFromUiDevice a, DisconnectFromUiDevice b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DisconnectFromUiDevice);
  }

  public bool Equals(DisconnectFromUiDevice p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._connectionType.Equals(p._connectionType)
      && this._deviceID.Equals(p._deviceID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._connectionType.GetHashCode();
      hash = hash * 23 + this._deviceID.GetHashCode();
      return hash;
    }
  }
}

public partial class UserLoggedIn
{
  /**** Constructors ****/

  public UserLoggedIn()
  {
  }

  public UserLoggedIn(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public UserLoggedIn(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class DriveWheels
{
  private float _lwheel_speed_mmps; // float_32
  private float _rwheel_speed_mmps; // float_32
  private float _lwheel_accel_mmps2 = 0.0f; // float_32
  private float _rwheel_accel_mmps2 = 0.0f; // float_32

  public float lwheel_speed_mmps { get { return _lwheel_speed_mmps; } set { _lwheel_speed_mmps = value; } }

  public float rwheel_speed_mmps { get { return _rwheel_speed_mmps; } set { _rwheel_speed_mmps = value; } }

  public float lwheel_accel_mmps2 { get { return _lwheel_accel_mmps2; } set { _lwheel_accel_mmps2 = value; } }

  public float rwheel_accel_mmps2 { get { return _rwheel_accel_mmps2; } set { _rwheel_accel_mmps2 = value; } }


  /**** Constructors ****/

  public DriveWheels()
  {
  }

  public DriveWheels(float lwheel_speed_mmps,
    float rwheel_speed_mmps,
    float lwheel_accel_mmps2,
    float rwheel_accel_mmps2)
  {
    this.lwheel_speed_mmps = lwheel_speed_mmps;
    this.rwheel_speed_mmps = rwheel_speed_mmps;
    this.lwheel_accel_mmps2 = lwheel_accel_mmps2;
    this.rwheel_accel_mmps2 = rwheel_accel_mmps2;
  }

  public DriveWheels(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DriveWheels(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DriveWheels Initialize(float lwheel_speed_mmps,
    float rwheel_speed_mmps,
    float lwheel_accel_mmps2,
    float rwheel_accel_mmps2)
  {
    this.lwheel_speed_mmps = lwheel_speed_mmps;
    this.rwheel_speed_mmps = rwheel_speed_mmps;
    this.lwheel_accel_mmps2 = lwheel_accel_mmps2;
    this.rwheel_accel_mmps2 = rwheel_accel_mmps2;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _lwheel_speed_mmps = reader.ReadSingle();
    _rwheel_speed_mmps = reader.ReadSingle();
    _lwheel_accel_mmps2 = reader.ReadSingle();
    _rwheel_accel_mmps2 = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_lwheel_speed_mmps);
    writer.Write((float)_rwheel_speed_mmps);
    writer.Write((float)_lwheel_accel_mmps2);
    writer.Write((float)_rwheel_accel_mmps2);
  }

  public int Size
  {
    get {
      return 16;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DriveWheels a, DriveWheels b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DriveWheels a, DriveWheels b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DriveWheels);
  }

  public bool Equals(DriveWheels p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._lwheel_speed_mmps.Equals(p._lwheel_speed_mmps)
      && this._rwheel_speed_mmps.Equals(p._rwheel_speed_mmps)
      && this._lwheel_accel_mmps2.Equals(p._lwheel_accel_mmps2)
      && this._rwheel_accel_mmps2.Equals(p._rwheel_accel_mmps2);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._lwheel_speed_mmps.GetHashCode();
      hash = hash * 23 + this._rwheel_speed_mmps.GetHashCode();
      hash = hash * 23 + this._lwheel_accel_mmps2.GetHashCode();
      hash = hash * 23 + this._rwheel_accel_mmps2.GetHashCode();
      return hash;
    }
  }
}

public partial class DriveArc
{
  private float _speed; // float_32
  private float _accel; // float_32
  private short _curvatureRadius_mm; // int_16

  public float speed { get { return _speed; } set { _speed = value; } }

  public float accel { get { return _accel; } set { _accel = value; } }

  public short curvatureRadius_mm { get { return _curvatureRadius_mm; } set { _curvatureRadius_mm = value; } }


  /**** Constructors ****/

  public DriveArc()
  {
  }

  public DriveArc(float speed,
    float accel,
    short curvatureRadius_mm)
  {
    this.speed = speed;
    this.accel = accel;
    this.curvatureRadius_mm = curvatureRadius_mm;
  }

  public DriveArc(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DriveArc(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DriveArc Initialize(float speed,
    float accel,
    short curvatureRadius_mm)
  {
    this.speed = speed;
    this.accel = accel;
    this.curvatureRadius_mm = curvatureRadius_mm;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _speed = reader.ReadSingle();
    _accel = reader.ReadSingle();
    _curvatureRadius_mm = reader.ReadInt16();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_speed);
    writer.Write((float)_accel);
    writer.Write((short)_curvatureRadius_mm);
  }

  public int Size
  {
    get {
      return 10;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DriveArc a, DriveArc b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DriveArc a, DriveArc b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DriveArc);
  }

  public bool Equals(DriveArc p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._speed.Equals(p._speed)
      && this._accel.Equals(p._accel)
      && this._curvatureRadius_mm.Equals(p._curvatureRadius_mm);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._speed.GetHashCode();
      hash = hash * 23 + this._accel.GetHashCode();
      hash = hash * 23 + this._curvatureRadius_mm.GetHashCode();
      return hash;
    }
  }
}

public partial class MoveHead
{
  private float _speed_rad_per_sec; // float_32

  public float speed_rad_per_sec { get { return _speed_rad_per_sec; } set { _speed_rad_per_sec = value; } }


  /**** Constructors ****/

  public MoveHead()
  {
  }

  public MoveHead(float speed_rad_per_sec)
  {
    this.speed_rad_per_sec = speed_rad_per_sec;
  }

  public MoveHead(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public MoveHead(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public MoveHead Initialize(float speed_rad_per_sec)
  {
    this.speed_rad_per_sec = speed_rad_per_sec;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _speed_rad_per_sec = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_speed_rad_per_sec);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(MoveHead a, MoveHead b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(MoveHead a, MoveHead b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as MoveHead);
  }

  public bool Equals(MoveHead p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._speed_rad_per_sec.Equals(p._speed_rad_per_sec);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._speed_rad_per_sec.GetHashCode();
      return hash;
    }
  }
}

public partial class MoveLift
{
  private float _speed_rad_per_sec; // float_32

  public float speed_rad_per_sec { get { return _speed_rad_per_sec; } set { _speed_rad_per_sec = value; } }


  /**** Constructors ****/

  public MoveLift()
  {
  }

  public MoveLift(float speed_rad_per_sec)
  {
    this.speed_rad_per_sec = speed_rad_per_sec;
  }

  public MoveLift(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public MoveLift(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public MoveLift Initialize(float speed_rad_per_sec)
  {
    this.speed_rad_per_sec = speed_rad_per_sec;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _speed_rad_per_sec = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_speed_rad_per_sec);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(MoveLift a, MoveLift b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(MoveLift a, MoveLift b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as MoveLift);
  }

  public bool Equals(MoveLift p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._speed_rad_per_sec.Equals(p._speed_rad_per_sec);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._speed_rad_per_sec.GetHashCode();
      return hash;
    }
  }
}

public partial class EnableLiftPower
{
  private bool _enable; // bool

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableLiftPower()
  {
  }

  public EnableLiftPower(bool enable)
  {
    this.enable = enable;
  }

  public EnableLiftPower(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableLiftPower(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableLiftPower Initialize(bool enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableLiftPower a, EnableLiftPower b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableLiftPower a, EnableLiftPower b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableLiftPower);
  }

  public bool Equals(EnableLiftPower p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class EnableCliffSensor
{
  private bool _enable; // bool

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableCliffSensor()
  {
  }

  public EnableCliffSensor(bool enable)
  {
    this.enable = enable;
  }

  public EnableCliffSensor(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableCliffSensor(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableCliffSensor Initialize(bool enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableCliffSensor a, EnableCliffSensor b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableCliffSensor a, EnableCliffSensor b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableCliffSensor);
  }

  public bool Equals(EnableCliffSensor p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class EnableStopOnCliff
{
  private bool _enable; // bool

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableStopOnCliff()
  {
  }

  public EnableStopOnCliff(bool enable)
  {
    this.enable = enable;
  }

  public EnableStopOnCliff(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableStopOnCliff(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableStopOnCliff Initialize(bool enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableStopOnCliff a, EnableStopOnCliff b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableStopOnCliff a, EnableStopOnCliff b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableStopOnCliff);
  }

  public bool Equals(EnableStopOnCliff p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class StopAllMotors
{
  /**** Constructors ****/

  public StopAllMotors()
  {
  }

  public StopAllMotors(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public StopAllMotors(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class ControllerGains
{
  private float _kp; // float_32
  private float _ki; // float_32
  private float _kd; // float_32
  private float _maxIntegralError; // float_32
  private Anki.Vector.ControllerChannel _controller; // ControllerChannel

  public float kp { get { return _kp; } set { _kp = value; } }

  public float ki { get { return _ki; } set { _ki = value; } }

  public float kd { get { return _kd; } set { _kd = value; } }

  public float maxIntegralError { get { return _maxIntegralError; } set { _maxIntegralError = value; } }

  public Anki.Vector.ControllerChannel controller { get { return _controller; } set { _controller = value; } }


  /**** Constructors ****/

  public ControllerGains()
  {
  }

  public ControllerGains(float kp,
    float ki,
    float kd,
    float maxIntegralError,
    Anki.Vector.ControllerChannel controller)
  {
    this.kp = kp;
    this.ki = ki;
    this.kd = kd;
    this.maxIntegralError = maxIntegralError;
    this.controller = controller;
  }

  public ControllerGains(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ControllerGains(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ControllerGains Initialize(float kp,
    float ki,
    float kd,
    float maxIntegralError,
    Anki.Vector.ControllerChannel controller)
  {
    this.kp = kp;
    this.ki = ki;
    this.kd = kd;
    this.maxIntegralError = maxIntegralError;
    this.controller = controller;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _kp = reader.ReadSingle();
    _ki = reader.ReadSingle();
    _kd = reader.ReadSingle();
    _maxIntegralError = reader.ReadSingle();
    _controller = (Anki.Vector.ControllerChannel)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_kp);
    writer.Write((float)_ki);
    writer.Write((float)_kd);
    writer.Write((float)_maxIntegralError);
    writer.Write((byte)_controller);
  }

  public int Size
  {
    get {
      return 17;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ControllerGains a, ControllerGains b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ControllerGains a, ControllerGains b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ControllerGains);
  }

  public bool Equals(ControllerGains p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._kp.Equals(p._kp)
      && this._ki.Equals(p._ki)
      && this._kd.Equals(p._kd)
      && this._maxIntegralError.Equals(p._maxIntegralError)
      && this._controller.Equals(p._controller);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._kp.GetHashCode();
      hash = hash * 23 + this._ki.GetHashCode();
      hash = hash * 23 + this._kd.GetHashCode();
      hash = hash * 23 + this._maxIntegralError.GetHashCode();
      hash = hash * 23 + this._controller.GetHashCode();
      return hash;
    }
  }
}

public partial class RollActionParams
{
  private float _liftHeight_mm; // float_32
  private float _driveSpeed_mmps; // float_32
  private float _driveAccel_mmps2; // float_32
  private uint _driveDuration_ms; // uint_32
  private float _backupDist_mm; // float_32

  public float liftHeight_mm { get { return _liftHeight_mm; } set { _liftHeight_mm = value; } }

  public float driveSpeed_mmps { get { return _driveSpeed_mmps; } set { _driveSpeed_mmps = value; } }

  public float driveAccel_mmps2 { get { return _driveAccel_mmps2; } set { _driveAccel_mmps2 = value; } }

  public uint driveDuration_ms { get { return _driveDuration_ms; } set { _driveDuration_ms = value; } }

  public float backupDist_mm { get { return _backupDist_mm; } set { _backupDist_mm = value; } }


  /**** Constructors ****/

  public RollActionParams()
  {
  }

  public RollActionParams(float liftHeight_mm,
    float driveSpeed_mmps,
    float driveAccel_mmps2,
    uint driveDuration_ms,
    float backupDist_mm)
  {
    this.liftHeight_mm = liftHeight_mm;
    this.driveSpeed_mmps = driveSpeed_mmps;
    this.driveAccel_mmps2 = driveAccel_mmps2;
    this.driveDuration_ms = driveDuration_ms;
    this.backupDist_mm = backupDist_mm;
  }

  public RollActionParams(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RollActionParams(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public RollActionParams Initialize(float liftHeight_mm,
    float driveSpeed_mmps,
    float driveAccel_mmps2,
    uint driveDuration_ms,
    float backupDist_mm)
  {
    this.liftHeight_mm = liftHeight_mm;
    this.driveSpeed_mmps = driveSpeed_mmps;
    this.driveAccel_mmps2 = driveAccel_mmps2;
    this.driveDuration_ms = driveDuration_ms;
    this.backupDist_mm = backupDist_mm;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _liftHeight_mm = reader.ReadSingle();
    _driveSpeed_mmps = reader.ReadSingle();
    _driveAccel_mmps2 = reader.ReadSingle();
    _driveDuration_ms = reader.ReadUInt32();
    _backupDist_mm = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_liftHeight_mm);
    writer.Write((float)_driveSpeed_mmps);
    writer.Write((float)_driveAccel_mmps2);
    writer.Write((uint)_driveDuration_ms);
    writer.Write((float)_backupDist_mm);
  }

  public int Size
  {
    get {
      return 20;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(RollActionParams a, RollActionParams b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(RollActionParams a, RollActionParams b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as RollActionParams);
  }

  public bool Equals(RollActionParams p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._liftHeight_mm.Equals(p._liftHeight_mm)
      && this._driveSpeed_mmps.Equals(p._driveSpeed_mmps)
      && this._driveAccel_mmps2.Equals(p._driveAccel_mmps2)
      && this._driveDuration_ms.Equals(p._driveDuration_ms)
      && this._backupDist_mm.Equals(p._backupDist_mm);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._liftHeight_mm.GetHashCode();
      hash = hash * 23 + this._driveSpeed_mmps.GetHashCode();
      hash = hash * 23 + this._driveAccel_mmps2.GetHashCode();
      hash = hash * 23 + this._driveDuration_ms.GetHashCode();
      hash = hash * 23 + this._backupDist_mm.GetHashCode();
      return hash;
    }
  }
}

public partial class SetMotionModelParams
{
  private float _slipFactor; // float_32

  public float slipFactor { get { return _slipFactor; } set { _slipFactor = value; } }


  /**** Constructors ****/

  public SetMotionModelParams()
  {
  }

  public SetMotionModelParams(float slipFactor)
  {
    this.slipFactor = slipFactor;
  }

  public SetMotionModelParams(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetMotionModelParams(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetMotionModelParams Initialize(float slipFactor)
  {
    this.slipFactor = slipFactor;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _slipFactor = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_slipFactor);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetMotionModelParams a, SetMotionModelParams b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetMotionModelParams a, SetMotionModelParams b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetMotionModelParams);
  }

  public bool Equals(SetMotionModelParams p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._slipFactor.Equals(p._slipFactor);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._slipFactor.GetHashCode();
      return hash;
    }
  }
}

public partial class SetRobotVolume
{
  private float _volume; // float_32

  public float volume { get { return _volume; } set { _volume = value; } }


  /**** Constructors ****/

  public SetRobotVolume()
  {
  }

  public SetRobotVolume(float volume)
  {
    this.volume = volume;
  }

  public SetRobotVolume(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetRobotVolume(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetRobotVolume Initialize(float volume)
  {
    this.volume = volume;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _volume = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_volume);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetRobotVolume a, SetRobotVolume b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetRobotVolume a, SetRobotVolume b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetRobotVolume);
  }

  public bool Equals(SetRobotVolume p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._volume.Equals(p._volume);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._volume.GetHashCode();
      return hash;
    }
  }
}

public partial class ForceDelocalizeRobot
{
  /**** Constructors ****/

  public ForceDelocalizeRobot()
  {
  }

  public ForceDelocalizeRobot(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ForceDelocalizeRobot(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class CancelAction
{
  private Anki.Vector.RobotActionType _actionType; // RobotActionType

  public Anki.Vector.RobotActionType actionType { get { return _actionType; } set { _actionType = value; } }


  /**** Constructors ****/

  public CancelAction()
  {
  }

  public CancelAction(Anki.Vector.RobotActionType actionType)
  {
    this.actionType = actionType;
  }

  public CancelAction(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public CancelAction(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public CancelAction Initialize(Anki.Vector.RobotActionType actionType)
  {
    this.actionType = actionType;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _actionType = (Anki.Vector.RobotActionType)reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_actionType);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(CancelAction a, CancelAction b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(CancelAction a, CancelAction b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as CancelAction);
  }

  public bool Equals(CancelAction p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._actionType.Equals(p._actionType);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._actionType.GetHashCode();
      return hash;
    }
  }
}

public partial class CancelActionByIdTag
{
  private uint _idTag; // uint_32

  public uint idTag { get { return _idTag; } set { _idTag = value; } }


  /**** Constructors ****/

  public CancelActionByIdTag()
  {
  }

  public CancelActionByIdTag(uint idTag)
  {
    this.idTag = idTag;
  }

  public CancelActionByIdTag(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public CancelActionByIdTag(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public CancelActionByIdTag Initialize(uint idTag)
  {
    this.idTag = idTag;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _idTag = reader.ReadUInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_idTag);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(CancelActionByIdTag a, CancelActionByIdTag b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(CancelActionByIdTag a, CancelActionByIdTag b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as CancelActionByIdTag);
  }

  public bool Equals(CancelActionByIdTag p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._idTag.Equals(p._idTag);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._idTag.GetHashCode();
      return hash;
    }
  }
}

public partial class QueueSingleAction
{
  private uint _idTag; // uint_32
  private byte _numRetries = 0; // uint_8
  private Anki.Vector.QueueActionPosition _position; // QueueActionPosition
  private Anki.Vector.ExternalInterface.RobotActionUnion _action; // RobotActionUnion

  public uint idTag { get { return _idTag; } set { _idTag = value; } }

  public byte numRetries { get { return _numRetries; } set { _numRetries = value; } }

  public Anki.Vector.QueueActionPosition position { get { return _position; } set { _position = value; } }

  public Anki.Vector.ExternalInterface.RobotActionUnion action
  {
    get {
      return _action;
    }
    set {
      if (value == null) {
        throw new System.ArgumentNullException("action cannot be null.", "value");
      }
      _action = value;
    }
  }


  /**** Constructors ****/

  public QueueSingleAction()
  {
    this.action = new Anki.Vector.ExternalInterface.RobotActionUnion();
  }

  public QueueSingleAction(uint idTag,
    byte numRetries,
    Anki.Vector.QueueActionPosition position,
    Anki.Vector.ExternalInterface.RobotActionUnion action)
  {
    this.idTag = idTag;
    this.numRetries = numRetries;
    this.position = position;
    this.action = action;
  }

  public QueueSingleAction(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public QueueSingleAction(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public QueueSingleAction Initialize(uint idTag,
    byte numRetries,
    Anki.Vector.QueueActionPosition position,
    Anki.Vector.ExternalInterface.RobotActionUnion action)
  {
    this.idTag = idTag;
    this.numRetries = numRetries;
    this.position = position;
    this.action = action;
    return this;
  }

  public QueueSingleAction Initialize<T0>(uint idTag,
    byte numRetries,
    Anki.Vector.QueueActionPosition position,
    T0 actionState)
  {
    this.idTag = idTag;
    this.numRetries = numRetries;
    this.position = position;
    this.action.Initialize<T0>(actionState);
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _idTag = reader.ReadUInt32();
    _numRetries = reader.ReadByte();
    _position = (Anki.Vector.QueueActionPosition)reader.ReadByte();
    _action = new Anki.Vector.ExternalInterface.RobotActionUnion(reader);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_idTag);
    writer.Write((byte)_numRetries);
    writer.Write((byte)_position);
    _action.Pack(writer);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 4; // uint_32
      result += 1; // uint_8
      result += 1; // QueueActionPosition
      result += action.Size;
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(QueueSingleAction a, QueueSingleAction b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(QueueSingleAction a, QueueSingleAction b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as QueueSingleAction);
  }

  public bool Equals(QueueSingleAction p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._idTag.Equals(p._idTag)
      && this._numRetries.Equals(p._numRetries)
      && this._position.Equals(p._position)
      && this._action.Equals(p._action);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._idTag.GetHashCode();
      hash = hash * 23 + this._numRetries.GetHashCode();
      hash = hash * 23 + this._position.GetHashCode();
      hash = hash * 23 + this._action.GetHashCode();
      return hash;
    }
  }
}

public partial class QueueCompoundAction
{
  private uint _idTag; // uint_32
  private byte _numRetries = 0; // uint_8
  private bool _parallel; // bool
  private Anki.Vector.QueueActionPosition _position; // QueueActionPosition
  private Anki.Vector.ExternalInterface.RobotActionUnion[] _actions; // RobotActionUnion[uint_8]

  public uint idTag { get { return _idTag; } set { _idTag = value; } }

  public byte numRetries { get { return _numRetries; } set { _numRetries = value; } }

  public bool parallel { get { return _parallel; } set { _parallel = value; } }

  public Anki.Vector.QueueActionPosition position { get { return _position; } set { _position = value; } }

  public Anki.Vector.ExternalInterface.RobotActionUnion[] actions
  {
    get {
      return _actions;
    }
    set {
      if (value != null && value.Length > 255) {
        throw new System.ArgumentException("actions variable-length array is too long. Must be less than or equal to 255.", "value");
      }
      _actions = value;
    }
  }


  /**** Constructors ****/

  public QueueCompoundAction()
  {
  }

  public QueueCompoundAction(uint idTag,
    byte numRetries,
    bool parallel,
    Anki.Vector.QueueActionPosition position,
    Anki.Vector.ExternalInterface.RobotActionUnion[] actions)
  {
    this.idTag = idTag;
    this.numRetries = numRetries;
    this.parallel = parallel;
    this.position = position;
    this.actions = actions;
  }

  public QueueCompoundAction(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public QueueCompoundAction(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public QueueCompoundAction Initialize(uint idTag,
    byte numRetries,
    bool parallel,
    Anki.Vector.QueueActionPosition position,
    Anki.Vector.ExternalInterface.RobotActionUnion[] actions)
  {
    this.idTag = idTag;
    this.numRetries = numRetries;
    this.parallel = parallel;
    this.position = position;
    this.actions = actions;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _idTag = reader.ReadUInt32();
    _numRetries = reader.ReadByte();
    _parallel = reader.ReadBoolean();
    _position = (Anki.Vector.QueueActionPosition)reader.ReadByte();
    int _actions_length = (int)reader.ReadByte();
    _actions = new Anki.Vector.ExternalInterface.RobotActionUnion[_actions_length];
    for (int i = 0; i < _actions_length; ++i) {
      _actions[i] = new Anki.Vector.ExternalInterface.RobotActionUnion(reader);
    }
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_idTag);
    writer.Write((byte)_numRetries);
    writer.Write((bool)_parallel);
    writer.Write((byte)_position);
    if (_actions != null) {
      writer.Write((byte)_actions.Length);
      for (int i = 0; i < _actions.Length; ++i) {
        if (_actions[i] == null) {
          throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
        }
        _actions[i].Pack(writer);
      }
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 4; // uint_32
      result += 1; // uint_8
      result += 1; // bool
      result += 1; // QueueActionPosition
      result += 1; // uint_8
      if (actions != null) {
        for (int i = 0; i < actions.Length; ++i) {
          if (actions[i] == null) {
            throw new System.InvalidOperationException("Messages may not have null members.");
          }
          result += actions[i].Size;
        }
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(QueueCompoundAction a, QueueCompoundAction b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(QueueCompoundAction a, QueueCompoundAction b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as QueueCompoundAction);
  }

  public bool Equals(QueueCompoundAction p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._idTag.Equals(p._idTag)
      && this._numRetries.Equals(p._numRetries)
      && this._parallel.Equals(p._parallel)
      && this._position.Equals(p._position)
      && ArrayEquals<Anki.Vector.ExternalInterface.RobotActionUnion>(this._actions,p._actions);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._idTag.GetHashCode();
      hash = hash * 23 + this._numRetries.GetHashCode();
      hash = hash * 23 + this._parallel.GetHashCode();
      hash = hash * 23 + this._position.GetHashCode();
      return hash;
    }
  }
}

public partial class RedirectViz
{
  private uint _ipAddr; // uint_32

  public uint ipAddr { get { return _ipAddr; } set { _ipAddr = value; } }


  /**** Constructors ****/

  public RedirectViz()
  {
  }

  public RedirectViz(uint ipAddr)
  {
    this.ipAddr = ipAddr;
  }

  public RedirectViz(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RedirectViz(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public RedirectViz Initialize(uint ipAddr)
  {
    this.ipAddr = ipAddr;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _ipAddr = reader.ReadUInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_ipAddr);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(RedirectViz a, RedirectViz b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(RedirectViz a, RedirectViz b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as RedirectViz);
  }

  public bool Equals(RedirectViz p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._ipAddr.Equals(p._ipAddr);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._ipAddr.GetHashCode();
      return hash;
    }
  }
}

public partial class ImageRequest
{
  private Anki.Vector.ImageSendMode _mode; // ImageSendMode

  public Anki.Vector.ImageSendMode mode { get { return _mode; } set { _mode = value; } }


  /**** Constructors ****/

  public ImageRequest()
  {
  }

  public ImageRequest(Anki.Vector.ImageSendMode mode)
  {
    this.mode = mode;
  }

  public ImageRequest(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ImageRequest(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ImageRequest Initialize(Anki.Vector.ImageSendMode mode)
  {
    this.mode = mode;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _mode = (Anki.Vector.ImageSendMode)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_mode);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ImageRequest a, ImageRequest b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ImageRequest a, ImageRequest b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ImageRequest);
  }

  public bool Equals(ImageRequest p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._mode.Equals(p._mode);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._mode.GetHashCode();
      return hash;
    }
  }
}

public partial class SaveImages
{
  private Anki.Vector.ImageSendMode _mode; // ImageSendMode
  private sbyte _qualityOnRobot; // int_8
  private bool _removeRadialDistortion = false; // bool
  private string _path; // string[uint_8]

  public Anki.Vector.ImageSendMode mode { get { return _mode; } set { _mode = value; } }

  public sbyte qualityOnRobot { get { return _qualityOnRobot; } set { _qualityOnRobot = value; } }

  public bool removeRadialDistortion { get { return _removeRadialDistortion; } set { _removeRadialDistortion = value; } }

  public string path
  {
    get {
      return _path;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("path string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _path = value;
    }
  }


  /**** Constructors ****/

  public SaveImages()
  {
  }

  public SaveImages(Anki.Vector.ImageSendMode mode,
    sbyte qualityOnRobot,
    bool removeRadialDistortion,
    string path)
  {
    this.mode = mode;
    this.qualityOnRobot = qualityOnRobot;
    this.removeRadialDistortion = removeRadialDistortion;
    this.path = path;
  }

  public SaveImages(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SaveImages(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SaveImages Initialize(Anki.Vector.ImageSendMode mode,
    sbyte qualityOnRobot,
    bool removeRadialDistortion,
    string path)
  {
    this.mode = mode;
    this.qualityOnRobot = qualityOnRobot;
    this.removeRadialDistortion = removeRadialDistortion;
    this.path = path;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _mode = (Anki.Vector.ImageSendMode)reader.ReadByte();
    _qualityOnRobot = reader.ReadSByte();
    _removeRadialDistortion = reader.ReadBoolean();
    int _path_length = (int)reader.ReadByte();
    byte[] _path_bytes = reader.ReadBytes(_path_length);
    _path = System.Text.Encoding.UTF8.GetString(_path_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_mode);
    writer.Write((sbyte)_qualityOnRobot);
    writer.Write((bool)_removeRadialDistortion);
    if (_path != null) {
      byte[] _path_bytes = System.Text.Encoding.UTF8.GetBytes(_path);
      writer.Write((byte)_path_bytes.Length);
      writer.Write(_path_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // ImageSendMode
      result += 1; // int_8
      result += 1; // bool
      result += 1; // uint_8
      if (path != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(path);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SaveImages a, SaveImages b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SaveImages a, SaveImages b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SaveImages);
  }

  public bool Equals(SaveImages p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._mode.Equals(p._mode)
      && this._qualityOnRobot.Equals(p._qualityOnRobot)
      && this._removeRadialDistortion.Equals(p._removeRadialDistortion)
      && this._path.Equals(p._path);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._mode.GetHashCode();
      hash = hash * 23 + this._qualityOnRobot.GetHashCode();
      hash = hash * 23 + this._removeRadialDistortion.GetHashCode();
      return hash;
    }
  }
}

public partial class EnableColorImages
{
  private bool _enable; // bool

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableColorImages()
  {
  }

  public EnableColorImages(bool enable)
  {
    this.enable = enable;
  }

  public EnableColorImages(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableColorImages(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableColorImages Initialize(bool enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableColorImages a, EnableColorImages b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableColorImages a, EnableColorImages b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableColorImages);
  }

  public bool Equals(EnableColorImages p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class SaveRobotState
{
  private bool _enabled; // bool
  private string _path; // string[uint_8]

  public bool enabled { get { return _enabled; } set { _enabled = value; } }

  public string path
  {
    get {
      return _path;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("path string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _path = value;
    }
  }


  /**** Constructors ****/

  public SaveRobotState()
  {
  }

  public SaveRobotState(bool enabled,
    string path)
  {
    this.enabled = enabled;
    this.path = path;
  }

  public SaveRobotState(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SaveRobotState(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SaveRobotState Initialize(bool enabled,
    string path)
  {
    this.enabled = enabled;
    this.path = path;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enabled = reader.ReadBoolean();
    int _path_length = (int)reader.ReadByte();
    byte[] _path_bytes = reader.ReadBytes(_path_length);
    _path = System.Text.Encoding.UTF8.GetString(_path_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enabled);
    if (_path != null) {
      byte[] _path_bytes = System.Text.Encoding.UTF8.GetBytes(_path);
      writer.Write((byte)_path_bytes.Length);
      writer.Write(_path_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // bool
      result += 1; // uint_8
      if (path != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(path);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SaveRobotState a, SaveRobotState b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SaveRobotState a, SaveRobotState b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SaveRobotState);
  }

  public bool Equals(SaveRobotState p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enabled.Equals(p._enabled)
      && this._path.Equals(p._path);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enabled.GetHashCode();
      return hash;
    }
  }
}

public partial class EnableDisplay
{
  private byte _enable; // uint_8

  public byte enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableDisplay()
  {
  }

  public EnableDisplay(byte enable)
  {
    this.enable = enable;
  }

  public EnableDisplay(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableDisplay(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableDisplay Initialize(byte enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableDisplay a, EnableDisplay b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableDisplay a, EnableDisplay b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableDisplay);
  }

  public bool Equals(EnableDisplay p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class ExecuteTestPlan
{
  private Anki.Vector.PathMotionProfile _motionProf; // PathMotionProfile

  public Anki.Vector.PathMotionProfile motionProf
  {
    get {
      return _motionProf;
    }
    set {
      if (value == null) {
        throw new System.ArgumentNullException("motionProf cannot be null.", "value");
      }
      _motionProf = value;
    }
  }


  /**** Constructors ****/

  public ExecuteTestPlan()
  {
    this.motionProf = new Anki.Vector.PathMotionProfile();
  }

  public ExecuteTestPlan(Anki.Vector.PathMotionProfile motionProf)
  {
    this.motionProf = motionProf;
  }

  public ExecuteTestPlan(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ExecuteTestPlan(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ExecuteTestPlan Initialize(Anki.Vector.PathMotionProfile motionProf)
  {
    this.motionProf = motionProf;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _motionProf = new Anki.Vector.PathMotionProfile(reader);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    _motionProf.Pack(writer);
  }

  public int Size
  {
    get {
      return 41;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ExecuteTestPlan a, ExecuteTestPlan b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ExecuteTestPlan a, ExecuteTestPlan b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ExecuteTestPlan);
  }

  public bool Equals(ExecuteTestPlan p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._motionProf.Equals(p._motionProf);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._motionProf.GetHashCode();
      return hash;
    }
  }
}

public partial class SelectNextObject
{
  /**** Constructors ****/

  public SelectNextObject()
  {
  }

  public SelectNextObject(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SelectNextObject(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class SetRobotCarryingObject
{
  private int _objectID; // int_32

  public int objectID { get { return _objectID; } set { _objectID = value; } }


  /**** Constructors ****/

  public SetRobotCarryingObject()
  {
  }

  public SetRobotCarryingObject(int objectID)
  {
    this.objectID = objectID;
  }

  public SetRobotCarryingObject(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetRobotCarryingObject(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetRobotCarryingObject Initialize(int objectID)
  {
    this.objectID = objectID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _objectID = reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_objectID);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetRobotCarryingObject a, SetRobotCarryingObject b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetRobotCarryingObject a, SetRobotCarryingObject b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetRobotCarryingObject);
  }

  public bool Equals(SetRobotCarryingObject p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._objectID.Equals(p._objectID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._objectID.GetHashCode();
      return hash;
    }
  }
}

public partial class DeleteAllCustomObjects
{
  /**** Constructors ****/

  public DeleteAllCustomObjects()
  {
  }

  public DeleteAllCustomObjects(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DeleteAllCustomObjects(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class DeleteCustomMarkerObjects
{
  /**** Constructors ****/

  public DeleteCustomMarkerObjects()
  {
  }

  public DeleteCustomMarkerObjects(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DeleteCustomMarkerObjects(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class DeleteFixedCustomObjects
{
  /**** Constructors ****/

  public DeleteFixedCustomObjects()
  {
  }

  public DeleteFixedCustomObjects(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DeleteFixedCustomObjects(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class UndefineAllCustomMarkerObjects
{
  /**** Constructors ****/

  public UndefineAllCustomMarkerObjects()
  {
  }

  public UndefineAllCustomMarkerObjects(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public UndefineAllCustomMarkerObjects(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class CreateFixedCustomObject
{
  private Anki.PoseStruct3d _pose; // PoseStruct3d
  private float _xSize_mm; // float_32
  private float _ySize_mm; // float_32
  private float _zSize_mm; // float_32

  public Anki.PoseStruct3d pose
  {
    get {
      return _pose;
    }
    set {
      if (value == null) {
        throw new System.ArgumentNullException("pose cannot be null.", "value");
      }
      _pose = value;
    }
  }

  public float xSize_mm { get { return _xSize_mm; } set { _xSize_mm = value; } }

  public float ySize_mm { get { return _ySize_mm; } set { _ySize_mm = value; } }

  public float zSize_mm { get { return _zSize_mm; } set { _zSize_mm = value; } }


  /**** Constructors ****/

  public CreateFixedCustomObject()
  {
    this.pose = new Anki.PoseStruct3d();
  }

  public CreateFixedCustomObject(Anki.PoseStruct3d pose,
    float xSize_mm,
    float ySize_mm,
    float zSize_mm)
  {
    this.pose = pose;
    this.xSize_mm = xSize_mm;
    this.ySize_mm = ySize_mm;
    this.zSize_mm = zSize_mm;
  }

  public CreateFixedCustomObject(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public CreateFixedCustomObject(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public CreateFixedCustomObject Initialize(Anki.PoseStruct3d pose,
    float xSize_mm,
    float ySize_mm,
    float zSize_mm)
  {
    this.pose = pose;
    this.xSize_mm = xSize_mm;
    this.ySize_mm = ySize_mm;
    this.zSize_mm = zSize_mm;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _pose = new Anki.PoseStruct3d(reader);
    _xSize_mm = reader.ReadSingle();
    _ySize_mm = reader.ReadSingle();
    _zSize_mm = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    _pose.Pack(writer);
    writer.Write((float)_xSize_mm);
    writer.Write((float)_ySize_mm);
    writer.Write((float)_zSize_mm);
  }

  public int Size
  {
    get {
      return 44;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(CreateFixedCustomObject a, CreateFixedCustomObject b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(CreateFixedCustomObject a, CreateFixedCustomObject b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as CreateFixedCustomObject);
  }

  public bool Equals(CreateFixedCustomObject p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._pose.Equals(p._pose)
      && this._xSize_mm.Equals(p._xSize_mm)
      && this._ySize_mm.Equals(p._ySize_mm)
      && this._zSize_mm.Equals(p._zSize_mm);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._pose.GetHashCode();
      hash = hash * 23 + this._xSize_mm.GetHashCode();
      hash = hash * 23 + this._ySize_mm.GetHashCode();
      hash = hash * 23 + this._zSize_mm.GetHashCode();
      return hash;
    }
  }
}

public partial class DefineCustomBox
{
  private Anki.Vector.ObjectType _customType; // ObjectType
  private Anki.Vector.CustomObjectMarker _markerFront; // CustomObjectMarker
  private Anki.Vector.CustomObjectMarker _markerBack; // CustomObjectMarker
  private Anki.Vector.CustomObjectMarker _markerTop; // CustomObjectMarker
  private Anki.Vector.CustomObjectMarker _markerBottom; // CustomObjectMarker
  private Anki.Vector.CustomObjectMarker _markerLeft; // CustomObjectMarker
  private Anki.Vector.CustomObjectMarker _markerRight; // CustomObjectMarker
  private float _xSize_mm; // float_32
  private float _ySize_mm; // float_32
  private float _zSize_mm; // float_32
  private float _markerWidth_mm; // float_32
  private float _markerHeight_mm; // float_32
  private bool _isUnique; // bool

  public Anki.Vector.ObjectType customType { get { return _customType; } set { _customType = value; } }

  public Anki.Vector.CustomObjectMarker markerFront { get { return _markerFront; } set { _markerFront = value; } }

  public Anki.Vector.CustomObjectMarker markerBack { get { return _markerBack; } set { _markerBack = value; } }

  public Anki.Vector.CustomObjectMarker markerTop { get { return _markerTop; } set { _markerTop = value; } }

  public Anki.Vector.CustomObjectMarker markerBottom { get { return _markerBottom; } set { _markerBottom = value; } }

  public Anki.Vector.CustomObjectMarker markerLeft { get { return _markerLeft; } set { _markerLeft = value; } }

  public Anki.Vector.CustomObjectMarker markerRight { get { return _markerRight; } set { _markerRight = value; } }

  public float xSize_mm { get { return _xSize_mm; } set { _xSize_mm = value; } }

  public float ySize_mm { get { return _ySize_mm; } set { _ySize_mm = value; } }

  public float zSize_mm { get { return _zSize_mm; } set { _zSize_mm = value; } }

  public float markerWidth_mm { get { return _markerWidth_mm; } set { _markerWidth_mm = value; } }

  public float markerHeight_mm { get { return _markerHeight_mm; } set { _markerHeight_mm = value; } }

  public bool isUnique { get { return _isUnique; } set { _isUnique = value; } }


  /**** Constructors ****/

  public DefineCustomBox()
  {
  }

  public DefineCustomBox(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker markerFront,
    Anki.Vector.CustomObjectMarker markerBack,
    Anki.Vector.CustomObjectMarker markerTop,
    Anki.Vector.CustomObjectMarker markerBottom,
    Anki.Vector.CustomObjectMarker markerLeft,
    Anki.Vector.CustomObjectMarker markerRight,
    float xSize_mm,
    float ySize_mm,
    float zSize_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.markerFront = markerFront;
    this.markerBack = markerBack;
    this.markerTop = markerTop;
    this.markerBottom = markerBottom;
    this.markerLeft = markerLeft;
    this.markerRight = markerRight;
    this.xSize_mm = xSize_mm;
    this.ySize_mm = ySize_mm;
    this.zSize_mm = zSize_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
  }

  public DefineCustomBox(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DefineCustomBox(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DefineCustomBox Initialize(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker markerFront,
    Anki.Vector.CustomObjectMarker markerBack,
    Anki.Vector.CustomObjectMarker markerTop,
    Anki.Vector.CustomObjectMarker markerBottom,
    Anki.Vector.CustomObjectMarker markerLeft,
    Anki.Vector.CustomObjectMarker markerRight,
    float xSize_mm,
    float ySize_mm,
    float zSize_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.markerFront = markerFront;
    this.markerBack = markerBack;
    this.markerTop = markerTop;
    this.markerBottom = markerBottom;
    this.markerLeft = markerLeft;
    this.markerRight = markerRight;
    this.xSize_mm = xSize_mm;
    this.ySize_mm = ySize_mm;
    this.zSize_mm = zSize_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _customType = (Anki.Vector.ObjectType)reader.ReadInt32();
    _markerFront = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _markerBack = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _markerTop = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _markerBottom = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _markerLeft = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _markerRight = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _xSize_mm = reader.ReadSingle();
    _ySize_mm = reader.ReadSingle();
    _zSize_mm = reader.ReadSingle();
    _markerWidth_mm = reader.ReadSingle();
    _markerHeight_mm = reader.ReadSingle();
    _isUnique = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_customType);
    writer.Write((short)_markerFront);
    writer.Write((short)_markerBack);
    writer.Write((short)_markerTop);
    writer.Write((short)_markerBottom);
    writer.Write((short)_markerLeft);
    writer.Write((short)_markerRight);
    writer.Write((float)_xSize_mm);
    writer.Write((float)_ySize_mm);
    writer.Write((float)_zSize_mm);
    writer.Write((float)_markerWidth_mm);
    writer.Write((float)_markerHeight_mm);
    writer.Write((bool)_isUnique);
  }

  public int Size
  {
    get {
      return 37;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DefineCustomBox a, DefineCustomBox b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DefineCustomBox a, DefineCustomBox b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DefineCustomBox);
  }

  public bool Equals(DefineCustomBox p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._customType.Equals(p._customType)
      && this._markerFront.Equals(p._markerFront)
      && this._markerBack.Equals(p._markerBack)
      && this._markerTop.Equals(p._markerTop)
      && this._markerBottom.Equals(p._markerBottom)
      && this._markerLeft.Equals(p._markerLeft)
      && this._markerRight.Equals(p._markerRight)
      && this._xSize_mm.Equals(p._xSize_mm)
      && this._ySize_mm.Equals(p._ySize_mm)
      && this._zSize_mm.Equals(p._zSize_mm)
      && this._markerWidth_mm.Equals(p._markerWidth_mm)
      && this._markerHeight_mm.Equals(p._markerHeight_mm)
      && this._isUnique.Equals(p._isUnique);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._customType.GetHashCode();
      hash = hash * 23 + this._markerFront.GetHashCode();
      hash = hash * 23 + this._markerBack.GetHashCode();
      hash = hash * 23 + this._markerTop.GetHashCode();
      hash = hash * 23 + this._markerBottom.GetHashCode();
      hash = hash * 23 + this._markerLeft.GetHashCode();
      hash = hash * 23 + this._markerRight.GetHashCode();
      hash = hash * 23 + this._xSize_mm.GetHashCode();
      hash = hash * 23 + this._ySize_mm.GetHashCode();
      hash = hash * 23 + this._zSize_mm.GetHashCode();
      hash = hash * 23 + this._markerWidth_mm.GetHashCode();
      hash = hash * 23 + this._markerHeight_mm.GetHashCode();
      hash = hash * 23 + this._isUnique.GetHashCode();
      return hash;
    }
  }
}

public partial class DefineCustomCube
{
  private Anki.Vector.ObjectType _customType; // ObjectType
  private Anki.Vector.CustomObjectMarker _marker; // CustomObjectMarker
  private float _size_mm; // float_32
  private float _markerWidth_mm; // float_32
  private float _markerHeight_mm; // float_32
  private bool _isUnique; // bool

  public Anki.Vector.ObjectType customType { get { return _customType; } set { _customType = value; } }

  public Anki.Vector.CustomObjectMarker marker { get { return _marker; } set { _marker = value; } }

  public float size_mm { get { return _size_mm; } set { _size_mm = value; } }

  public float markerWidth_mm { get { return _markerWidth_mm; } set { _markerWidth_mm = value; } }

  public float markerHeight_mm { get { return _markerHeight_mm; } set { _markerHeight_mm = value; } }

  public bool isUnique { get { return _isUnique; } set { _isUnique = value; } }


  /**** Constructors ****/

  public DefineCustomCube()
  {
  }

  public DefineCustomCube(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker marker,
    float size_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.marker = marker;
    this.size_mm = size_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
  }

  public DefineCustomCube(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DefineCustomCube(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DefineCustomCube Initialize(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker marker,
    float size_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.marker = marker;
    this.size_mm = size_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _customType = (Anki.Vector.ObjectType)reader.ReadInt32();
    _marker = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _size_mm = reader.ReadSingle();
    _markerWidth_mm = reader.ReadSingle();
    _markerHeight_mm = reader.ReadSingle();
    _isUnique = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_customType);
    writer.Write((short)_marker);
    writer.Write((float)_size_mm);
    writer.Write((float)_markerWidth_mm);
    writer.Write((float)_markerHeight_mm);
    writer.Write((bool)_isUnique);
  }

  public int Size
  {
    get {
      return 19;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DefineCustomCube a, DefineCustomCube b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DefineCustomCube a, DefineCustomCube b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DefineCustomCube);
  }

  public bool Equals(DefineCustomCube p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._customType.Equals(p._customType)
      && this._marker.Equals(p._marker)
      && this._size_mm.Equals(p._size_mm)
      && this._markerWidth_mm.Equals(p._markerWidth_mm)
      && this._markerHeight_mm.Equals(p._markerHeight_mm)
      && this._isUnique.Equals(p._isUnique);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._customType.GetHashCode();
      hash = hash * 23 + this._marker.GetHashCode();
      hash = hash * 23 + this._size_mm.GetHashCode();
      hash = hash * 23 + this._markerWidth_mm.GetHashCode();
      hash = hash * 23 + this._markerHeight_mm.GetHashCode();
      hash = hash * 23 + this._isUnique.GetHashCode();
      return hash;
    }
  }
}

public partial class DefineCustomWall
{
  private Anki.Vector.ObjectType _customType; // ObjectType
  private Anki.Vector.CustomObjectMarker _marker; // CustomObjectMarker
  private float _width_mm; // float_32
  private float _height_mm; // float_32
  private float _markerWidth_mm; // float_32
  private float _markerHeight_mm; // float_32
  private bool _isUnique; // bool

  public Anki.Vector.ObjectType customType { get { return _customType; } set { _customType = value; } }

  public Anki.Vector.CustomObjectMarker marker { get { return _marker; } set { _marker = value; } }

  public float width_mm { get { return _width_mm; } set { _width_mm = value; } }

  public float height_mm { get { return _height_mm; } set { _height_mm = value; } }

  public float markerWidth_mm { get { return _markerWidth_mm; } set { _markerWidth_mm = value; } }

  public float markerHeight_mm { get { return _markerHeight_mm; } set { _markerHeight_mm = value; } }

  public bool isUnique { get { return _isUnique; } set { _isUnique = value; } }


  /**** Constructors ****/

  public DefineCustomWall()
  {
  }

  public DefineCustomWall(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker marker,
    float width_mm,
    float height_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.marker = marker;
    this.width_mm = width_mm;
    this.height_mm = height_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
  }

  public DefineCustomWall(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DefineCustomWall(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DefineCustomWall Initialize(Anki.Vector.ObjectType customType,
    Anki.Vector.CustomObjectMarker marker,
    float width_mm,
    float height_mm,
    float markerWidth_mm,
    float markerHeight_mm,
    bool isUnique)
  {
    this.customType = customType;
    this.marker = marker;
    this.width_mm = width_mm;
    this.height_mm = height_mm;
    this.markerWidth_mm = markerWidth_mm;
    this.markerHeight_mm = markerHeight_mm;
    this.isUnique = isUnique;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _customType = (Anki.Vector.ObjectType)reader.ReadInt32();
    _marker = (Anki.Vector.CustomObjectMarker)reader.ReadInt16();
    _width_mm = reader.ReadSingle();
    _height_mm = reader.ReadSingle();
    _markerWidth_mm = reader.ReadSingle();
    _markerHeight_mm = reader.ReadSingle();
    _isUnique = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_customType);
    writer.Write((short)_marker);
    writer.Write((float)_width_mm);
    writer.Write((float)_height_mm);
    writer.Write((float)_markerWidth_mm);
    writer.Write((float)_markerHeight_mm);
    writer.Write((bool)_isUnique);
  }

  public int Size
  {
    get {
      return 23;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DefineCustomWall a, DefineCustomWall b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DefineCustomWall a, DefineCustomWall b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DefineCustomWall);
  }

  public bool Equals(DefineCustomWall p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._customType.Equals(p._customType)
      && this._marker.Equals(p._marker)
      && this._width_mm.Equals(p._width_mm)
      && this._height_mm.Equals(p._height_mm)
      && this._markerWidth_mm.Equals(p._markerWidth_mm)
      && this._markerHeight_mm.Equals(p._markerHeight_mm)
      && this._isUnique.Equals(p._isUnique);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._customType.GetHashCode();
      hash = hash * 23 + this._marker.GetHashCode();
      hash = hash * 23 + this._width_mm.GetHashCode();
      hash = hash * 23 + this._height_mm.GetHashCode();
      hash = hash * 23 + this._markerWidth_mm.GetHashCode();
      hash = hash * 23 + this._markerHeight_mm.GetHashCode();
      hash = hash * 23 + this._isUnique.GetHashCode();
      return hash;
    }
  }
}

public partial class VisionWhileMoving
{
  private byte _enable; // uint_8

  public byte enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public VisionWhileMoving()
  {
  }

  public VisionWhileMoving(byte enable)
  {
    this.enable = enable;
  }

  public VisionWhileMoving(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public VisionWhileMoving(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public VisionWhileMoving Initialize(byte enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(VisionWhileMoving a, VisionWhileMoving b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(VisionWhileMoving a, VisionWhileMoving b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as VisionWhileMoving);
  }

  public bool Equals(VisionWhileMoving p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class SetFaceToEnroll
{
  private string _name; // string[uint_8]
  private int _observedID = 0; // int_32
  private int _saveID = 0; // int_32
  private bool _saveToRobot = true; // bool
  private bool _sayName = false; // bool
  private bool _useMusic = false; // bool

  public string name
  {
    get {
      return _name;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("name string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _name = value;
    }
  }

  public int observedID { get { return _observedID; } set { _observedID = value; } }

  public int saveID { get { return _saveID; } set { _saveID = value; } }

  public bool saveToRobot { get { return _saveToRobot; } set { _saveToRobot = value; } }

  public bool sayName { get { return _sayName; } set { _sayName = value; } }

  public bool useMusic { get { return _useMusic; } set { _useMusic = value; } }


  /**** Constructors ****/

  public SetFaceToEnroll()
  {
  }

  public SetFaceToEnroll(string name,
    int observedID,
    int saveID,
    bool saveToRobot,
    bool sayName,
    bool useMusic)
  {
    this.name = name;
    this.observedID = observedID;
    this.saveID = saveID;
    this.saveToRobot = saveToRobot;
    this.sayName = sayName;
    this.useMusic = useMusic;
  }

  public SetFaceToEnroll(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetFaceToEnroll(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetFaceToEnroll Initialize(string name,
    int observedID,
    int saveID,
    bool saveToRobot,
    bool sayName,
    bool useMusic)
  {
    this.name = name;
    this.observedID = observedID;
    this.saveID = saveID;
    this.saveToRobot = saveToRobot;
    this.sayName = sayName;
    this.useMusic = useMusic;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _name_length = (int)reader.ReadByte();
    byte[] _name_bytes = reader.ReadBytes(_name_length);
    _name = System.Text.Encoding.UTF8.GetString(_name_bytes);
    _observedID = reader.ReadInt32();
    _saveID = reader.ReadInt32();
    _saveToRobot = reader.ReadBoolean();
    _sayName = reader.ReadBoolean();
    _useMusic = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_name != null) {
      byte[] _name_bytes = System.Text.Encoding.UTF8.GetBytes(_name);
      writer.Write((byte)_name_bytes.Length);
      writer.Write(_name_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    writer.Write((int)_observedID);
    writer.Write((int)_saveID);
    writer.Write((bool)_saveToRobot);
    writer.Write((bool)_sayName);
    writer.Write((bool)_useMusic);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (name != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(name);
      }
      result += 4; // int_32
      result += 4; // int_32
      result += 1; // bool
      result += 1; // bool
      result += 1; // bool
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetFaceToEnroll a, SetFaceToEnroll b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetFaceToEnroll a, SetFaceToEnroll b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetFaceToEnroll);
  }

  public bool Equals(SetFaceToEnroll p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._name.Equals(p._name)
      && this._observedID.Equals(p._observedID)
      && this._saveID.Equals(p._saveID)
      && this._saveToRobot.Equals(p._saveToRobot)
      && this._sayName.Equals(p._sayName)
      && this._useMusic.Equals(p._useMusic);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._observedID.GetHashCode();
      hash = hash * 23 + this._saveID.GetHashCode();
      hash = hash * 23 + this._saveToRobot.GetHashCode();
      hash = hash * 23 + this._sayName.GetHashCode();
      hash = hash * 23 + this._useMusic.GetHashCode();
      return hash;
    }
  }
}

public partial class CancelFaceEnrollment
{
  /**** Constructors ****/

  public CancelFaceEnrollment()
  {
  }

  public CancelFaceEnrollment(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public CancelFaceEnrollment(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class RequestEnrolledNames
{
  /**** Constructors ****/

  public RequestEnrolledNames()
  {
  }

  public RequestEnrolledNames(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RequestEnrolledNames(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class EraseEnrolledFaceByID
{
  private int _faceID; // int_32

  public int faceID { get { return _faceID; } set { _faceID = value; } }


  /**** Constructors ****/

  public EraseEnrolledFaceByID()
  {
  }

  public EraseEnrolledFaceByID(int faceID)
  {
    this.faceID = faceID;
  }

  public EraseEnrolledFaceByID(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EraseEnrolledFaceByID(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EraseEnrolledFaceByID Initialize(int faceID)
  {
    this.faceID = faceID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _faceID = reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_faceID);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EraseEnrolledFaceByID a, EraseEnrolledFaceByID b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EraseEnrolledFaceByID a, EraseEnrolledFaceByID b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EraseEnrolledFaceByID);
  }

  public bool Equals(EraseEnrolledFaceByID p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._faceID.Equals(p._faceID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._faceID.GetHashCode();
      return hash;
    }
  }
}

public partial class EraseAllEnrolledFaces
{
  /**** Constructors ****/

  public EraseAllEnrolledFaces()
  {
  }

  public EraseAllEnrolledFaces(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EraseAllEnrolledFaces(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class EnableVisionMode
{
  private Anki.Vector.VisionMode _mode; // VisionMode
  private bool _enable; // bool

  public Anki.Vector.VisionMode mode { get { return _mode; } set { _mode = value; } }

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public EnableVisionMode()
  {
  }

  public EnableVisionMode(Anki.Vector.VisionMode mode,
    bool enable)
  {
    this.mode = mode;
    this.enable = enable;
  }

  public EnableVisionMode(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableVisionMode(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableVisionMode Initialize(Anki.Vector.VisionMode mode,
    bool enable)
  {
    this.mode = mode;
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _mode = (Anki.Vector.VisionMode)reader.ReadUInt32();
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_mode);
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 5;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableVisionMode a, EnableVisionMode b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableVisionMode a, EnableVisionMode b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableVisionMode);
  }

  public bool Equals(EnableVisionMode p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._mode.Equals(p._mode)
      && this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._mode.GetHashCode();
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class UpdateEnrolledFaceByID
{
  private int _faceID; // int_32
  private string _oldName; // string[uint_8]
  private string _newName; // string[uint_8]

  public int faceID { get { return _faceID; } set { _faceID = value; } }

  public string oldName
  {
    get {
      return _oldName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("oldName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _oldName = value;
    }
  }

  public string newName
  {
    get {
      return _newName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("newName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _newName = value;
    }
  }


  /**** Constructors ****/

  public UpdateEnrolledFaceByID()
  {
  }

  public UpdateEnrolledFaceByID(int faceID,
    string oldName,
    string newName)
  {
    this.faceID = faceID;
    this.oldName = oldName;
    this.newName = newName;
  }

  public UpdateEnrolledFaceByID(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public UpdateEnrolledFaceByID(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public UpdateEnrolledFaceByID Initialize(int faceID,
    string oldName,
    string newName)
  {
    this.faceID = faceID;
    this.oldName = oldName;
    this.newName = newName;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _faceID = reader.ReadInt32();
    int _oldName_length = (int)reader.ReadByte();
    byte[] _oldName_bytes = reader.ReadBytes(_oldName_length);
    _oldName = System.Text.Encoding.UTF8.GetString(_oldName_bytes);
    int _newName_length = (int)reader.ReadByte();
    byte[] _newName_bytes = reader.ReadBytes(_newName_length);
    _newName = System.Text.Encoding.UTF8.GetString(_newName_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_faceID);
    if (_oldName != null) {
      byte[] _oldName_bytes = System.Text.Encoding.UTF8.GetBytes(_oldName);
      writer.Write((byte)_oldName_bytes.Length);
      writer.Write(_oldName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_newName != null) {
      byte[] _newName_bytes = System.Text.Encoding.UTF8.GetBytes(_newName);
      writer.Write((byte)_newName_bytes.Length);
      writer.Write(_newName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 4; // int_32
      result += 1; // uint_8
      if (oldName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(oldName);
      }
      result += 1; // uint_8
      if (newName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(newName);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(UpdateEnrolledFaceByID a, UpdateEnrolledFaceByID b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(UpdateEnrolledFaceByID a, UpdateEnrolledFaceByID b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as UpdateEnrolledFaceByID);
  }

  public bool Equals(UpdateEnrolledFaceByID p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._faceID.Equals(p._faceID)
      && this._oldName.Equals(p._oldName)
      && this._newName.Equals(p._newName);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._faceID.GetHashCode();
      return hash;
    }
  }
}

public partial class VisionRunMode
{
  private bool _isSync; // bool

  public bool isSync { get { return _isSync; } set { _isSync = value; } }


  /**** Constructors ****/

  public VisionRunMode()
  {
  }

  public VisionRunMode(bool isSync)
  {
    this.isSync = isSync;
  }

  public VisionRunMode(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public VisionRunMode(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public VisionRunMode Initialize(bool isSync)
  {
    this.isSync = isSync;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _isSync = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_isSync);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(VisionRunMode a, VisionRunMode b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(VisionRunMode a, VisionRunMode b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as VisionRunMode);
  }

  public bool Equals(VisionRunMode p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._isSync.Equals(p._isSync);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._isSync.GetHashCode();
      return hash;
    }
  }
}

public partial class SaveFaceAlbumToFile
{
  private string _path; // string[uint_8]
  private bool _isRelativePath = true; // bool

  public string path
  {
    get {
      return _path;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("path string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _path = value;
    }
  }

  public bool isRelativePath { get { return _isRelativePath; } set { _isRelativePath = value; } }


  /**** Constructors ****/

  public SaveFaceAlbumToFile()
  {
  }

  public SaveFaceAlbumToFile(string path,
    bool isRelativePath)
  {
    this.path = path;
    this.isRelativePath = isRelativePath;
  }

  public SaveFaceAlbumToFile(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SaveFaceAlbumToFile(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SaveFaceAlbumToFile Initialize(string path,
    bool isRelativePath)
  {
    this.path = path;
    this.isRelativePath = isRelativePath;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _path_length = (int)reader.ReadByte();
    byte[] _path_bytes = reader.ReadBytes(_path_length);
    _path = System.Text.Encoding.UTF8.GetString(_path_bytes);
    _isRelativePath = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_path != null) {
      byte[] _path_bytes = System.Text.Encoding.UTF8.GetBytes(_path);
      writer.Write((byte)_path_bytes.Length);
      writer.Write(_path_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    writer.Write((bool)_isRelativePath);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (path != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(path);
      }
      result += 1; // bool
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SaveFaceAlbumToFile a, SaveFaceAlbumToFile b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SaveFaceAlbumToFile a, SaveFaceAlbumToFile b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SaveFaceAlbumToFile);
  }

  public bool Equals(SaveFaceAlbumToFile p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._path.Equals(p._path)
      && this._isRelativePath.Equals(p._isRelativePath);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._isRelativePath.GetHashCode();
      return hash;
    }
  }
}

public partial class LoadFaceAlbumFromFile
{
  private string _path; // string[uint_8]
  private bool _isRelativePath = true; // bool

  public string path
  {
    get {
      return _path;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("path string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _path = value;
    }
  }

  public bool isRelativePath { get { return _isRelativePath; } set { _isRelativePath = value; } }


  /**** Constructors ****/

  public LoadFaceAlbumFromFile()
  {
  }

  public LoadFaceAlbumFromFile(string path,
    bool isRelativePath)
  {
    this.path = path;
    this.isRelativePath = isRelativePath;
  }

  public LoadFaceAlbumFromFile(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public LoadFaceAlbumFromFile(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public LoadFaceAlbumFromFile Initialize(string path,
    bool isRelativePath)
  {
    this.path = path;
    this.isRelativePath = isRelativePath;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _path_length = (int)reader.ReadByte();
    byte[] _path_bytes = reader.ReadBytes(_path_length);
    _path = System.Text.Encoding.UTF8.GetString(_path_bytes);
    _isRelativePath = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_path != null) {
      byte[] _path_bytes = System.Text.Encoding.UTF8.GetBytes(_path);
      writer.Write((byte)_path_bytes.Length);
      writer.Write(_path_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    writer.Write((bool)_isRelativePath);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (path != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(path);
      }
      result += 1; // bool
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(LoadFaceAlbumFromFile a, LoadFaceAlbumFromFile b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(LoadFaceAlbumFromFile a, LoadFaceAlbumFromFile b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as LoadFaceAlbumFromFile);
  }

  public bool Equals(LoadFaceAlbumFromFile p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._path.Equals(p._path)
      && this._isRelativePath.Equals(p._isRelativePath);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._isRelativePath.GetHashCode();
      return hash;
    }
  }
}

public partial class SetCameraCaptureFormat
{
  private Anki.Vision.ImageEncoding _format; // ImageEncoding

  public Anki.Vision.ImageEncoding format { get { return _format; } set { _format = value; } }


  /**** Constructors ****/

  public SetCameraCaptureFormat()
  {
  }

  public SetCameraCaptureFormat(Anki.Vision.ImageEncoding format)
  {
    this.format = format;
  }

  public SetCameraCaptureFormat(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetCameraCaptureFormat(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetCameraCaptureFormat Initialize(Anki.Vision.ImageEncoding format)
  {
    this.format = format;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _format = (Anki.Vision.ImageEncoding)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_format);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetCameraCaptureFormat a, SetCameraCaptureFormat b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetCameraCaptureFormat a, SetCameraCaptureFormat b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetCameraCaptureFormat);
  }

  public bool Equals(SetCameraCaptureFormat p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._format.Equals(p._format);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._format.GetHashCode();
      return hash;
    }
  }
}

public partial class SetMemoryMapRenderEnabled
{
  private bool _enabled; // bool

  public bool enabled { get { return _enabled; } set { _enabled = value; } }


  /**** Constructors ****/

  public SetMemoryMapRenderEnabled()
  {
  }

  public SetMemoryMapRenderEnabled(bool enabled)
  {
    this.enabled = enabled;
  }

  public SetMemoryMapRenderEnabled(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetMemoryMapRenderEnabled(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetMemoryMapRenderEnabled Initialize(bool enabled)
  {
    this.enabled = enabled;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enabled = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enabled);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetMemoryMapRenderEnabled a, SetMemoryMapRenderEnabled b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetMemoryMapRenderEnabled a, SetMemoryMapRenderEnabled b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetMemoryMapRenderEnabled);
  }

  public bool Equals(SetMemoryMapRenderEnabled p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enabled.Equals(p._enabled);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enabled.GetHashCode();
      return hash;
    }
  }
}

public partial class SetMemoryMapBroadcastFrequency_sec
{
  private float _frequency = -1.0f; // float_32

  public float frequency { get { return _frequency; } set { _frequency = value; } }


  /**** Constructors ****/

  public SetMemoryMapBroadcastFrequency_sec()
  {
  }

  public SetMemoryMapBroadcastFrequency_sec(float frequency)
  {
    this.frequency = frequency;
  }

  public SetMemoryMapBroadcastFrequency_sec(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetMemoryMapBroadcastFrequency_sec(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetMemoryMapBroadcastFrequency_sec Initialize(float frequency)
  {
    this.frequency = frequency;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _frequency = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_frequency);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetMemoryMapBroadcastFrequency_sec a, SetMemoryMapBroadcastFrequency_sec b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetMemoryMapBroadcastFrequency_sec a, SetMemoryMapBroadcastFrequency_sec b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetMemoryMapBroadcastFrequency_sec);
  }

  public bool Equals(SetMemoryMapBroadcastFrequency_sec p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._frequency.Equals(p._frequency);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._frequency.GetHashCode();
      return hash;
    }
  }
}

public partial class FakeTriggerWordDetected
{
  /**** Constructors ****/

  public FakeTriggerWordDetected()
  {
  }

  public FakeTriggerWordDetected(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public FakeTriggerWordDetected(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class FakeCloudIntent
{
  private string _intent; // string[uint_8]

  public string intent
  {
    get {
      return _intent;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("intent string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _intent = value;
    }
  }


  /**** Constructors ****/

  public FakeCloudIntent()
  {
  }

  public FakeCloudIntent(string intent)
  {
    this.intent = intent;
  }

  public FakeCloudIntent(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public FakeCloudIntent(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public FakeCloudIntent Initialize(string intent)
  {
    this.intent = intent;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _intent_length = (int)reader.ReadByte();
    byte[] _intent_bytes = reader.ReadBytes(_intent_length);
    _intent = System.Text.Encoding.UTF8.GetString(_intent_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_intent != null) {
      byte[] _intent_bytes = System.Text.Encoding.UTF8.GetBytes(_intent);
      writer.Write((byte)_intent_bytes.Length);
      writer.Write(_intent_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (intent != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(intent);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(FakeCloudIntent a, FakeCloudIntent b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(FakeCloudIntent a, FakeCloudIntent b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as FakeCloudIntent);
  }

  public bool Equals(FakeCloudIntent p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._intent.Equals(p._intent);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class FakeUserIntent
{
  private string _intent; // string[uint_8]

  public string intent
  {
    get {
      return _intent;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("intent string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _intent = value;
    }
  }


  /**** Constructors ****/

  public FakeUserIntent()
  {
  }

  public FakeUserIntent(string intent)
  {
    this.intent = intent;
  }

  public FakeUserIntent(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public FakeUserIntent(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public FakeUserIntent Initialize(string intent)
  {
    this.intent = intent;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _intent_length = (int)reader.ReadByte();
    byte[] _intent_bytes = reader.ReadBytes(_intent_length);
    _intent = System.Text.Encoding.UTF8.GetString(_intent_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_intent != null) {
      byte[] _intent_bytes = System.Text.Encoding.UTF8.GetBytes(_intent);
      writer.Write((byte)_intent_bytes.Length);
      writer.Write(_intent_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (intent != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(intent);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(FakeUserIntent a, FakeUserIntent b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(FakeUserIntent a, FakeUserIntent b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as FakeUserIntent);
  }

  public bool Equals(FakeUserIntent p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._intent.Equals(p._intent);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class ExecuteBehaviorByID
{
  private string _behaviorID; // string[uint_8]
  private int _numRuns = -1; // int_32
  private bool _presetConditions = false; // bool

  public string behaviorID
  {
    get {
      return _behaviorID;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("behaviorID string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _behaviorID = value;
    }
  }

  public int numRuns { get { return _numRuns; } set { _numRuns = value; } }

  public bool presetConditions { get { return _presetConditions; } set { _presetConditions = value; } }


  /**** Constructors ****/

  public ExecuteBehaviorByID()
  {
  }

  public ExecuteBehaviorByID(string behaviorID,
    int numRuns,
    bool presetConditions)
  {
    this.behaviorID = behaviorID;
    this.numRuns = numRuns;
    this.presetConditions = presetConditions;
  }

  public ExecuteBehaviorByID(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ExecuteBehaviorByID(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ExecuteBehaviorByID Initialize(string behaviorID,
    int numRuns,
    bool presetConditions)
  {
    this.behaviorID = behaviorID;
    this.numRuns = numRuns;
    this.presetConditions = presetConditions;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _behaviorID_length = (int)reader.ReadByte();
    byte[] _behaviorID_bytes = reader.ReadBytes(_behaviorID_length);
    _behaviorID = System.Text.Encoding.UTF8.GetString(_behaviorID_bytes);
    _numRuns = reader.ReadInt32();
    _presetConditions = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_behaviorID != null) {
      byte[] _behaviorID_bytes = System.Text.Encoding.UTF8.GetBytes(_behaviorID);
      writer.Write((byte)_behaviorID_bytes.Length);
      writer.Write(_behaviorID_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    writer.Write((int)_numRuns);
    writer.Write((bool)_presetConditions);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (behaviorID != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(behaviorID);
      }
      result += 4; // int_32
      result += 1; // bool
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ExecuteBehaviorByID a, ExecuteBehaviorByID b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ExecuteBehaviorByID a, ExecuteBehaviorByID b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ExecuteBehaviorByID);
  }

  public bool Equals(ExecuteBehaviorByID p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._behaviorID.Equals(p._behaviorID)
      && this._numRuns.Equals(p._numRuns)
      && this._presetConditions.Equals(p._presetConditions);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._numRuns.GetHashCode();
      hash = hash * 23 + this._presetConditions.GetHashCode();
      return hash;
    }
  }
}

public partial class SetLiftLoadTestAsActivatable
{
  /**** Constructors ****/

  public SetLiftLoadTestAsActivatable()
  {
  }

  public SetLiftLoadTestAsActivatable(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetLiftLoadTestAsActivatable(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class AbortPath
{
  /**** Constructors ****/

  public AbortPath()
  {
  }

  public AbortPath(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public AbortPath(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class AbortAll
{
  /**** Constructors ****/

  public AbortAll()
  {
  }

  public AbortAll(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public AbortAll(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class StartTestMode
{
  private int _p1; // int_32
  private int _p2; // int_32
  private int _p3; // int_32
  private Anki.Vector.TestMode _mode; // TestMode

  public int p1 { get { return _p1; } set { _p1 = value; } }

  public int p2 { get { return _p2; } set { _p2 = value; } }

  public int p3 { get { return _p3; } set { _p3 = value; } }

  public Anki.Vector.TestMode mode { get { return _mode; } set { _mode = value; } }


  /**** Constructors ****/

  public StartTestMode()
  {
  }

  public StartTestMode(int p1,
    int p2,
    int p3,
    Anki.Vector.TestMode mode)
  {
    this.p1 = p1;
    this.p2 = p2;
    this.p3 = p3;
    this.mode = mode;
  }

  public StartTestMode(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public StartTestMode(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public StartTestMode Initialize(int p1,
    int p2,
    int p3,
    Anki.Vector.TestMode mode)
  {
    this.p1 = p1;
    this.p2 = p2;
    this.p3 = p3;
    this.mode = mode;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _p1 = reader.ReadInt32();
    _p2 = reader.ReadInt32();
    _p3 = reader.ReadInt32();
    _mode = (Anki.Vector.TestMode)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_p1);
    writer.Write((int)_p2);
    writer.Write((int)_p3);
    writer.Write((byte)_mode);
  }

  public int Size
  {
    get {
      return 13;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(StartTestMode a, StartTestMode b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(StartTestMode a, StartTestMode b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as StartTestMode);
  }

  public bool Equals(StartTestMode p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._p1.Equals(p._p1)
      && this._p2.Equals(p._p2)
      && this._p3.Equals(p._p3)
      && this._mode.Equals(p._mode);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._p1.GetHashCode();
      hash = hash * 23 + this._p2.GetHashCode();
      hash = hash * 23 + this._p3.GetHashCode();
      hash = hash * 23 + this._mode.GetHashCode();
      return hash;
    }
  }
}

public partial class AppIntent
{
  private string _intent; // string[uint_8]
  private string _param; // string[uint_8]

  public string intent
  {
    get {
      return _intent;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("intent string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _intent = value;
    }
  }

  public string param
  {
    get {
      return _param;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("param string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _param = value;
    }
  }


  /**** Constructors ****/

  public AppIntent()
  {
  }

  public AppIntent(string intent,
    string param)
  {
    this.intent = intent;
    this.param = param;
  }

  public AppIntent(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public AppIntent(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public AppIntent Initialize(string intent,
    string param)
  {
    this.intent = intent;
    this.param = param;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _intent_length = (int)reader.ReadByte();
    byte[] _intent_bytes = reader.ReadBytes(_intent_length);
    _intent = System.Text.Encoding.UTF8.GetString(_intent_bytes);
    int _param_length = (int)reader.ReadByte();
    byte[] _param_bytes = reader.ReadBytes(_param_length);
    _param = System.Text.Encoding.UTF8.GetString(_param_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_intent != null) {
      byte[] _intent_bytes = System.Text.Encoding.UTF8.GetBytes(_intent);
      writer.Write((byte)_intent_bytes.Length);
      writer.Write(_intent_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_param != null) {
      byte[] _param_bytes = System.Text.Encoding.UTF8.GetBytes(_param);
      writer.Write((byte)_param_bytes.Length);
      writer.Write(_param_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (intent != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(intent);
      }
      result += 1; // uint_8
      if (param != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(param);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(AppIntent a, AppIntent b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(AppIntent a, AppIntent b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as AppIntent);
  }

  public bool Equals(AppIntent p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._intent.Equals(p._intent)
      && this._param.Equals(p._param);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class DrawPoseMarker
{
  private float _x_mm; // float_32
  private float _y_mm; // float_32
  private float _rad; // float_32
  private byte _level; // uint_8

  public float x_mm { get { return _x_mm; } set { _x_mm = value; } }

  public float y_mm { get { return _y_mm; } set { _y_mm = value; } }

  public float rad { get { return _rad; } set { _rad = value; } }

  public byte level { get { return _level; } set { _level = value; } }


  /**** Constructors ****/

  public DrawPoseMarker()
  {
  }

  public DrawPoseMarker(float x_mm,
    float y_mm,
    float rad,
    byte level)
  {
    this.x_mm = x_mm;
    this.y_mm = y_mm;
    this.rad = rad;
    this.level = level;
  }

  public DrawPoseMarker(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DrawPoseMarker(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DrawPoseMarker Initialize(float x_mm,
    float y_mm,
    float rad,
    byte level)
  {
    this.x_mm = x_mm;
    this.y_mm = y_mm;
    this.rad = rad;
    this.level = level;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _x_mm = reader.ReadSingle();
    _y_mm = reader.ReadSingle();
    _rad = reader.ReadSingle();
    _level = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_x_mm);
    writer.Write((float)_y_mm);
    writer.Write((float)_rad);
    writer.Write((byte)_level);
  }

  public int Size
  {
    get {
      return 13;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DrawPoseMarker a, DrawPoseMarker b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DrawPoseMarker a, DrawPoseMarker b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DrawPoseMarker);
  }

  public bool Equals(DrawPoseMarker p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._x_mm.Equals(p._x_mm)
      && this._y_mm.Equals(p._y_mm)
      && this._rad.Equals(p._rad)
      && this._level.Equals(p._level);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._x_mm.GetHashCode();
      hash = hash * 23 + this._y_mm.GetHashCode();
      hash = hash * 23 + this._rad.GetHashCode();
      hash = hash * 23 + this._level.GetHashCode();
      return hash;
    }
  }
}

public partial class ErasePoseMarker
{
  /**** Constructors ****/

  public ErasePoseMarker()
  {
  }

  public ErasePoseMarker(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ErasePoseMarker(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class VisualizeQuad
{
  private uint _quadID; // uint_32
  private uint _color; // uint_32
  private float _xUpperLeft; // float_32
  private float _yUpperLeft; // float_32
  private float _zUpperLeft; // float_32
  private float _xLowerLeft; // float_32
  private float _yLowerLeft; // float_32
  private float _zLowerLeft; // float_32
  private float _xUpperRight; // float_32
  private float _yUpperRight; // float_32
  private float _zUpperRight; // float_32
  private float _xLowerRight; // float_32
  private float _yLowerRight; // float_32
  private float _zLowerRight; // float_32

  public uint quadID { get { return _quadID; } set { _quadID = value; } }

  public uint color { get { return _color; } set { _color = value; } }

  public float xUpperLeft { get { return _xUpperLeft; } set { _xUpperLeft = value; } }

  public float yUpperLeft { get { return _yUpperLeft; } set { _yUpperLeft = value; } }

  public float zUpperLeft { get { return _zUpperLeft; } set { _zUpperLeft = value; } }

  public float xLowerLeft { get { return _xLowerLeft; } set { _xLowerLeft = value; } }

  public float yLowerLeft { get { return _yLowerLeft; } set { _yLowerLeft = value; } }

  public float zLowerLeft { get { return _zLowerLeft; } set { _zLowerLeft = value; } }

  public float xUpperRight { get { return _xUpperRight; } set { _xUpperRight = value; } }

  public float yUpperRight { get { return _yUpperRight; } set { _yUpperRight = value; } }

  public float zUpperRight { get { return _zUpperRight; } set { _zUpperRight = value; } }

  public float xLowerRight { get { return _xLowerRight; } set { _xLowerRight = value; } }

  public float yLowerRight { get { return _yLowerRight; } set { _yLowerRight = value; } }

  public float zLowerRight { get { return _zLowerRight; } set { _zLowerRight = value; } }


  /**** Constructors ****/

  public VisualizeQuad()
  {
  }

  public VisualizeQuad(uint quadID,
    uint color,
    float xUpperLeft,
    float yUpperLeft,
    float zUpperLeft,
    float xLowerLeft,
    float yLowerLeft,
    float zLowerLeft,
    float xUpperRight,
    float yUpperRight,
    float zUpperRight,
    float xLowerRight,
    float yLowerRight,
    float zLowerRight)
  {
    this.quadID = quadID;
    this.color = color;
    this.xUpperLeft = xUpperLeft;
    this.yUpperLeft = yUpperLeft;
    this.zUpperLeft = zUpperLeft;
    this.xLowerLeft = xLowerLeft;
    this.yLowerLeft = yLowerLeft;
    this.zLowerLeft = zLowerLeft;
    this.xUpperRight = xUpperRight;
    this.yUpperRight = yUpperRight;
    this.zUpperRight = zUpperRight;
    this.xLowerRight = xLowerRight;
    this.yLowerRight = yLowerRight;
    this.zLowerRight = zLowerRight;
  }

  public VisualizeQuad(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public VisualizeQuad(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public VisualizeQuad Initialize(uint quadID,
    uint color,
    float xUpperLeft,
    float yUpperLeft,
    float zUpperLeft,
    float xLowerLeft,
    float yLowerLeft,
    float zLowerLeft,
    float xUpperRight,
    float yUpperRight,
    float zUpperRight,
    float xLowerRight,
    float yLowerRight,
    float zLowerRight)
  {
    this.quadID = quadID;
    this.color = color;
    this.xUpperLeft = xUpperLeft;
    this.yUpperLeft = yUpperLeft;
    this.zUpperLeft = zUpperLeft;
    this.xLowerLeft = xLowerLeft;
    this.yLowerLeft = yLowerLeft;
    this.zLowerLeft = zLowerLeft;
    this.xUpperRight = xUpperRight;
    this.yUpperRight = yUpperRight;
    this.zUpperRight = zUpperRight;
    this.xLowerRight = xLowerRight;
    this.yLowerRight = yLowerRight;
    this.zLowerRight = zLowerRight;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _quadID = reader.ReadUInt32();
    _color = reader.ReadUInt32();
    _xUpperLeft = reader.ReadSingle();
    _yUpperLeft = reader.ReadSingle();
    _zUpperLeft = reader.ReadSingle();
    _xLowerLeft = reader.ReadSingle();
    _yLowerLeft = reader.ReadSingle();
    _zLowerLeft = reader.ReadSingle();
    _xUpperRight = reader.ReadSingle();
    _yUpperRight = reader.ReadSingle();
    _zUpperRight = reader.ReadSingle();
    _xLowerRight = reader.ReadSingle();
    _yLowerRight = reader.ReadSingle();
    _zLowerRight = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_quadID);
    writer.Write((uint)_color);
    writer.Write((float)_xUpperLeft);
    writer.Write((float)_yUpperLeft);
    writer.Write((float)_zUpperLeft);
    writer.Write((float)_xLowerLeft);
    writer.Write((float)_yLowerLeft);
    writer.Write((float)_zLowerLeft);
    writer.Write((float)_xUpperRight);
    writer.Write((float)_yUpperRight);
    writer.Write((float)_zUpperRight);
    writer.Write((float)_xLowerRight);
    writer.Write((float)_yLowerRight);
    writer.Write((float)_zLowerRight);
  }

  public int Size
  {
    get {
      return 56;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(VisualizeQuad a, VisualizeQuad b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(VisualizeQuad a, VisualizeQuad b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as VisualizeQuad);
  }

  public bool Equals(VisualizeQuad p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._quadID.Equals(p._quadID)
      && this._color.Equals(p._color)
      && this._xUpperLeft.Equals(p._xUpperLeft)
      && this._yUpperLeft.Equals(p._yUpperLeft)
      && this._zUpperLeft.Equals(p._zUpperLeft)
      && this._xLowerLeft.Equals(p._xLowerLeft)
      && this._yLowerLeft.Equals(p._yLowerLeft)
      && this._zLowerLeft.Equals(p._zLowerLeft)
      && this._xUpperRight.Equals(p._xUpperRight)
      && this._yUpperRight.Equals(p._yUpperRight)
      && this._zUpperRight.Equals(p._zUpperRight)
      && this._xLowerRight.Equals(p._xLowerRight)
      && this._yLowerRight.Equals(p._yLowerRight)
      && this._zLowerRight.Equals(p._zLowerRight);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._quadID.GetHashCode();
      hash = hash * 23 + this._color.GetHashCode();
      hash = hash * 23 + this._xUpperLeft.GetHashCode();
      hash = hash * 23 + this._yUpperLeft.GetHashCode();
      hash = hash * 23 + this._zUpperLeft.GetHashCode();
      hash = hash * 23 + this._xLowerLeft.GetHashCode();
      hash = hash * 23 + this._yLowerLeft.GetHashCode();
      hash = hash * 23 + this._zLowerLeft.GetHashCode();
      hash = hash * 23 + this._xUpperRight.GetHashCode();
      hash = hash * 23 + this._yUpperRight.GetHashCode();
      hash = hash * 23 + this._zUpperRight.GetHashCode();
      hash = hash * 23 + this._xLowerRight.GetHashCode();
      hash = hash * 23 + this._yLowerRight.GetHashCode();
      hash = hash * 23 + this._zLowerRight.GetHashCode();
      return hash;
    }
  }
}

public partial class EraseQuad
{
  private uint _quadID; // uint_32

  public uint quadID { get { return _quadID; } set { _quadID = value; } }


  /**** Constructors ****/

  public EraseQuad()
  {
  }

  public EraseQuad(uint quadID)
  {
    this.quadID = quadID;
  }

  public EraseQuad(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EraseQuad(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EraseQuad Initialize(uint quadID)
  {
    this.quadID = quadID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _quadID = reader.ReadUInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_quadID);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EraseQuad a, EraseQuad b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EraseQuad a, EraseQuad b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EraseQuad);
  }

  public bool Equals(EraseQuad p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._quadID.Equals(p._quadID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._quadID.GetHashCode();
      return hash;
    }
  }
}

public partial class ReadAnimationFile
{
  private string _full_path; // string[uint_8]

  public string full_path
  {
    get {
      return _full_path;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("full_path string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _full_path = value;
    }
  }


  /**** Constructors ****/

  public ReadAnimationFile()
  {
  }

  public ReadAnimationFile(string full_path)
  {
    this.full_path = full_path;
  }

  public ReadAnimationFile(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ReadAnimationFile(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public ReadAnimationFile Initialize(string full_path)
  {
    this.full_path = full_path;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _full_path_length = (int)reader.ReadByte();
    byte[] _full_path_bytes = reader.ReadBytes(_full_path_length);
    _full_path = System.Text.Encoding.UTF8.GetString(_full_path_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_full_path != null) {
      byte[] _full_path_bytes = System.Text.Encoding.UTF8.GetBytes(_full_path);
      writer.Write((byte)_full_path_bytes.Length);
      writer.Write(_full_path_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (full_path != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(full_path);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(ReadAnimationFile a, ReadAnimationFile b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(ReadAnimationFile a, ReadAnimationFile b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as ReadAnimationFile);
  }

  public bool Equals(ReadAnimationFile p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._full_path.Equals(p._full_path);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class RequestAvailableAnimations
{
  /**** Constructors ****/

  public RequestAvailableAnimations()
  {
  }

  public RequestAvailableAnimations(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RequestAvailableAnimations(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class RequestAvailableAnimationGroups
{
  /**** Constructors ****/

  public RequestAvailableAnimationGroups()
  {
  }

  public RequestAvailableAnimationGroups(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RequestAvailableAnimationGroups(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class PushDrivingAnimations
{
  private Anki.Vector.AnimationTrigger _drivingStartAnim; // AnimationTrigger
  private Anki.Vector.AnimationTrigger _drivingLoopAnim; // AnimationTrigger
  private Anki.Vector.AnimationTrigger _drivingEndAnim; // AnimationTrigger
  private string _lockName; // string[uint_8]

  public Anki.Vector.AnimationTrigger drivingStartAnim { get { return _drivingStartAnim; } set { _drivingStartAnim = value; } }

  public Anki.Vector.AnimationTrigger drivingLoopAnim { get { return _drivingLoopAnim; } set { _drivingLoopAnim = value; } }

  public Anki.Vector.AnimationTrigger drivingEndAnim { get { return _drivingEndAnim; } set { _drivingEndAnim = value; } }

  public string lockName
  {
    get {
      return _lockName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("lockName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _lockName = value;
    }
  }


  /**** Constructors ****/

  public PushDrivingAnimations()
  {
  }

  public PushDrivingAnimations(Anki.Vector.AnimationTrigger drivingStartAnim,
    Anki.Vector.AnimationTrigger drivingLoopAnim,
    Anki.Vector.AnimationTrigger drivingEndAnim,
    string lockName)
  {
    this.drivingStartAnim = drivingStartAnim;
    this.drivingLoopAnim = drivingLoopAnim;
    this.drivingEndAnim = drivingEndAnim;
    this.lockName = lockName;
  }

  public PushDrivingAnimations(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public PushDrivingAnimations(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public PushDrivingAnimations Initialize(Anki.Vector.AnimationTrigger drivingStartAnim,
    Anki.Vector.AnimationTrigger drivingLoopAnim,
    Anki.Vector.AnimationTrigger drivingEndAnim,
    string lockName)
  {
    this.drivingStartAnim = drivingStartAnim;
    this.drivingLoopAnim = drivingLoopAnim;
    this.drivingEndAnim = drivingEndAnim;
    this.lockName = lockName;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _drivingStartAnim = (Anki.Vector.AnimationTrigger)reader.ReadInt32();
    _drivingLoopAnim = (Anki.Vector.AnimationTrigger)reader.ReadInt32();
    _drivingEndAnim = (Anki.Vector.AnimationTrigger)reader.ReadInt32();
    int _lockName_length = (int)reader.ReadByte();
    byte[] _lockName_bytes = reader.ReadBytes(_lockName_length);
    _lockName = System.Text.Encoding.UTF8.GetString(_lockName_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((int)_drivingStartAnim);
    writer.Write((int)_drivingLoopAnim);
    writer.Write((int)_drivingEndAnim);
    if (_lockName != null) {
      byte[] _lockName_bytes = System.Text.Encoding.UTF8.GetBytes(_lockName);
      writer.Write((byte)_lockName_bytes.Length);
      writer.Write(_lockName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 4; // AnimationTrigger
      result += 4; // AnimationTrigger
      result += 4; // AnimationTrigger
      result += 1; // uint_8
      if (lockName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(lockName);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(PushDrivingAnimations a, PushDrivingAnimations b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(PushDrivingAnimations a, PushDrivingAnimations b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as PushDrivingAnimations);
  }

  public bool Equals(PushDrivingAnimations p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._drivingStartAnim.Equals(p._drivingStartAnim)
      && this._drivingLoopAnim.Equals(p._drivingLoopAnim)
      && this._drivingEndAnim.Equals(p._drivingEndAnim)
      && this._lockName.Equals(p._lockName);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._drivingStartAnim.GetHashCode();
      hash = hash * 23 + this._drivingLoopAnim.GetHashCode();
      hash = hash * 23 + this._drivingEndAnim.GetHashCode();
      return hash;
    }
  }
}

public partial class RemoveDrivingAnimations
{
  private string _lockName; // string[uint_8]

  public string lockName
  {
    get {
      return _lockName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("lockName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _lockName = value;
    }
  }


  /**** Constructors ****/

  public RemoveDrivingAnimations()
  {
  }

  public RemoveDrivingAnimations(string lockName)
  {
    this.lockName = lockName;
  }

  public RemoveDrivingAnimations(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RemoveDrivingAnimations(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public RemoveDrivingAnimations Initialize(string lockName)
  {
    this.lockName = lockName;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _lockName_length = (int)reader.ReadByte();
    byte[] _lockName_bytes = reader.ReadBytes(_lockName_length);
    _lockName = System.Text.Encoding.UTF8.GetString(_lockName_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_lockName != null) {
      byte[] _lockName_bytes = System.Text.Encoding.UTF8.GetBytes(_lockName);
      writer.Write((byte)_lockName_bytes.Length);
      writer.Write(_lockName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (lockName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(lockName);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(RemoveDrivingAnimations a, RemoveDrivingAnimations b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(RemoveDrivingAnimations a, RemoveDrivingAnimations b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as RemoveDrivingAnimations);
  }

  public bool Equals(RemoveDrivingAnimations p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._lockName.Equals(p._lockName);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class DisplayProceduralFace
{
  private Anki.Vector.ProceduralFaceParameters _faceParams; // ProceduralFaceParameters
  private uint _duration_ms; // uint_32
  private bool _interruptRunning; // bool

  public Anki.Vector.ProceduralFaceParameters faceParams
  {
    get {
      return _faceParams;
    }
    set {
      if (value == null) {
        throw new System.ArgumentNullException("faceParams cannot be null.", "value");
      }
      _faceParams = value;
    }
  }

  public uint duration_ms { get { return _duration_ms; } set { _duration_ms = value; } }

  public bool interruptRunning { get { return _interruptRunning; } set { _interruptRunning = value; } }


  /**** Constructors ****/

  public DisplayProceduralFace()
  {
    this.faceParams = new Anki.Vector.ProceduralFaceParameters();
  }

  public DisplayProceduralFace(Anki.Vector.ProceduralFaceParameters faceParams,
    uint duration_ms,
    bool interruptRunning)
  {
    this.faceParams = faceParams;
    this.duration_ms = duration_ms;
    this.interruptRunning = interruptRunning;
  }

  public DisplayProceduralFace(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DisplayProceduralFace(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DisplayProceduralFace Initialize(Anki.Vector.ProceduralFaceParameters faceParams,
    uint duration_ms,
    bool interruptRunning)
  {
    this.faceParams = faceParams;
    this.duration_ms = duration_ms;
    this.interruptRunning = interruptRunning;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _faceParams = new Anki.Vector.ProceduralFaceParameters(reader);
    _duration_ms = reader.ReadUInt32();
    _interruptRunning = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    _faceParams.Pack(writer);
    writer.Write((uint)_duration_ms);
    writer.Write((bool)_interruptRunning);
  }

  public int Size
  {
    get {
      return 229;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DisplayProceduralFace a, DisplayProceduralFace b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DisplayProceduralFace a, DisplayProceduralFace b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DisplayProceduralFace);
  }

  public bool Equals(DisplayProceduralFace p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._faceParams.Equals(p._faceParams)
      && this._duration_ms.Equals(p._duration_ms)
      && this._interruptRunning.Equals(p._interruptRunning);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._faceParams.GetHashCode();
      hash = hash * 23 + this._duration_ms.GetHashCode();
      hash = hash * 23 + this._interruptRunning.GetHashCode();
      return hash;
    }
  }
}

public partial class SetFaceHue
{
  private float _hue; // float_32

  public float hue { get { return _hue; } set { _hue = value; } }


  /**** Constructors ****/

  public SetFaceHue()
  {
  }

  public SetFaceHue(float hue)
  {
    this.hue = hue;
  }

  public SetFaceHue(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetFaceHue(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetFaceHue Initialize(float hue)
  {
    this.hue = hue;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _hue = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_hue);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetFaceHue a, SetFaceHue b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetFaceHue a, SetFaceHue b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetFaceHue);
  }

  public bool Equals(SetFaceHue p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._hue.Equals(p._hue);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._hue.GetHashCode();
      return hash;
    }
  }
}

public partial class DisplayFaceImageBinaryChunk
{
  private uint _duration_ms; // uint_32
  private byte[] _faceData; // uint_8[1104]
  private byte _imageId; // uint_8
  private byte _chunkIndex; // uint_8
  private bool _interruptRunning; // bool

  public uint duration_ms { get { return _duration_ms; } set { _duration_ms = value; } }

  public byte[] faceData
  {
    get {
      return _faceData;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("faceData fixed-length array is null. Must have a length of 1104.", "value");
      }
      if (value.Length != 1104) {
        throw new System.ArgumentException("faceData fixed-length array is the wrong size. Must have a length of 1104.", "value");
      }
      _faceData = value;
    }
  }

  public byte imageId { get { return _imageId; } set { _imageId = value; } }

  public byte chunkIndex { get { return _chunkIndex; } set { _chunkIndex = value; } }

  public bool interruptRunning { get { return _interruptRunning; } set { _interruptRunning = value; } }


  /**** Constructors ****/

  public DisplayFaceImageBinaryChunk()
  {
    this.faceData = new byte[1104];
  }

  public DisplayFaceImageBinaryChunk(uint duration_ms,
    byte[] faceData,
    byte imageId,
    byte chunkIndex,
    bool interruptRunning)
  {
    this.duration_ms = duration_ms;
    this.faceData = faceData;
    this.imageId = imageId;
    this.chunkIndex = chunkIndex;
    this.interruptRunning = interruptRunning;
  }

  public DisplayFaceImageBinaryChunk(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DisplayFaceImageBinaryChunk(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DisplayFaceImageBinaryChunk Initialize(uint duration_ms,
    byte[] faceData,
    byte imageId,
    byte chunkIndex,
    bool interruptRunning)
  {
    this.duration_ms = duration_ms;
    this.faceData = faceData;
    this.imageId = imageId;
    this.chunkIndex = chunkIndex;
    this.interruptRunning = interruptRunning;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _duration_ms = reader.ReadUInt32();
    _faceData = new byte[1104];
    for (int i = 0; i < 1104; ++i) {
      _faceData[i] = reader.ReadByte();
    }
    _imageId = reader.ReadByte();
    _chunkIndex = reader.ReadByte();
    _interruptRunning = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_duration_ms);
    for (int i = 0; i < 1104; ++i) {
      writer.Write((byte)_faceData[i]);
    }
    writer.Write((byte)_imageId);
    writer.Write((byte)_chunkIndex);
    writer.Write((bool)_interruptRunning);
  }

  public int Size
  {
    get {
      return 1111;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DisplayFaceImageBinaryChunk a, DisplayFaceImageBinaryChunk b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DisplayFaceImageBinaryChunk a, DisplayFaceImageBinaryChunk b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DisplayFaceImageBinaryChunk);
  }

  public bool Equals(DisplayFaceImageBinaryChunk p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._duration_ms.Equals(p._duration_ms)
      && ArrayEquals<byte>(this._faceData,p._faceData)
      && this._imageId.Equals(p._imageId)
      && this._chunkIndex.Equals(p._chunkIndex)
      && this._interruptRunning.Equals(p._interruptRunning);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._duration_ms.GetHashCode();
      hash = hash * 23 + this._imageId.GetHashCode();
      hash = hash * 23 + this._chunkIndex.GetHashCode();
      hash = hash * 23 + this._interruptRunning.GetHashCode();
      return hash;
    }
  }
}

public partial class DisplayFaceImageRGBChunk
{
  private ushort[] _faceData; // uint_16[600]
  private ushort _numPixels; // uint_16
  private byte _chunkIndex; // uint_8
  private byte _numChunks; // uint_8
  private uint _duration_ms; // uint_32
  private bool _interruptRunning; // bool

  public ushort[] faceData
  {
    get {
      return _faceData;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("faceData fixed-length array is null. Must have a length of 600.", "value");
      }
      if (value.Length != 600) {
        throw new System.ArgumentException("faceData fixed-length array is the wrong size. Must have a length of 600.", "value");
      }
      _faceData = value;
    }
  }

  public ushort numPixels { get { return _numPixels; } set { _numPixels = value; } }

  public byte chunkIndex { get { return _chunkIndex; } set { _chunkIndex = value; } }

  public byte numChunks { get { return _numChunks; } set { _numChunks = value; } }

  public uint duration_ms { get { return _duration_ms; } set { _duration_ms = value; } }

  public bool interruptRunning { get { return _interruptRunning; } set { _interruptRunning = value; } }


  /**** Constructors ****/

  public DisplayFaceImageRGBChunk()
  {
    this.faceData = new ushort[600];
  }

  public DisplayFaceImageRGBChunk(ushort[] faceData,
    ushort numPixels,
    byte chunkIndex,
    byte numChunks,
    uint duration_ms,
    bool interruptRunning)
  {
    this.faceData = faceData;
    this.numPixels = numPixels;
    this.chunkIndex = chunkIndex;
    this.numChunks = numChunks;
    this.duration_ms = duration_ms;
    this.interruptRunning = interruptRunning;
  }

  public DisplayFaceImageRGBChunk(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DisplayFaceImageRGBChunk(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DisplayFaceImageRGBChunk Initialize(ushort[] faceData,
    ushort numPixels,
    byte chunkIndex,
    byte numChunks,
    uint duration_ms,
    bool interruptRunning)
  {
    this.faceData = faceData;
    this.numPixels = numPixels;
    this.chunkIndex = chunkIndex;
    this.numChunks = numChunks;
    this.duration_ms = duration_ms;
    this.interruptRunning = interruptRunning;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _faceData = new ushort[600];
    for (int i = 0; i < 600; ++i) {
      _faceData[i] = reader.ReadUInt16();
    }
    _numPixels = reader.ReadUInt16();
    _chunkIndex = reader.ReadByte();
    _numChunks = reader.ReadByte();
    _duration_ms = reader.ReadUInt32();
    _interruptRunning = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    for (int i = 0; i < 600; ++i) {
      writer.Write((ushort)_faceData[i]);
    }
    writer.Write((ushort)_numPixels);
    writer.Write((byte)_chunkIndex);
    writer.Write((byte)_numChunks);
    writer.Write((uint)_duration_ms);
    writer.Write((bool)_interruptRunning);
  }

  public int Size
  {
    get {
      return 1209;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DisplayFaceImageRGBChunk a, DisplayFaceImageRGBChunk b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DisplayFaceImageRGBChunk a, DisplayFaceImageRGBChunk b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DisplayFaceImageRGBChunk);
  }

  public bool Equals(DisplayFaceImageRGBChunk p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return ArrayEquals<ushort>(this._faceData,p._faceData)
      && this._numPixels.Equals(p._numPixels)
      && this._chunkIndex.Equals(p._chunkIndex)
      && this._numChunks.Equals(p._numChunks)
      && this._duration_ms.Equals(p._duration_ms)
      && this._interruptRunning.Equals(p._interruptRunning);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._numPixels.GetHashCode();
      hash = hash * 23 + this._chunkIndex.GetHashCode();
      hash = hash * 23 + this._numChunks.GetHashCode();
      hash = hash * 23 + this._duration_ms.GetHashCode();
      hash = hash * 23 + this._interruptRunning.GetHashCode();
      return hash;
    }
  }
}

public partial class SetActiveObjectLEDs
{
  private uint _objectID; // uint_32
  private uint _onColor; // uint_32
  private uint _offColor; // uint_32
  private uint _onPeriod_ms; // uint_32
  private uint _offPeriod_ms; // uint_32
  private uint _transitionOnPeriod_ms; // uint_32
  private uint _transitionOffPeriod_ms; // uint_32
  private int _offset = 0; // int_32
  private float _relativeToX; // float_32
  private float _relativeToY; // float_32
  private bool _rotate = false; // bool
  private Anki.Vector.WhichCubeLEDs _whichLEDs; // WhichCubeLEDs
  private Anki.Vector.MakeRelativeMode _makeRelative; // MakeRelativeMode
  private byte _turnOffUnspecifiedLEDs; // uint_8

  public uint objectID { get { return _objectID; } set { _objectID = value; } }

  public uint onColor { get { return _onColor; } set { _onColor = value; } }

  public uint offColor { get { return _offColor; } set { _offColor = value; } }

  public uint onPeriod_ms { get { return _onPeriod_ms; } set { _onPeriod_ms = value; } }

  public uint offPeriod_ms { get { return _offPeriod_ms; } set { _offPeriod_ms = value; } }

  public uint transitionOnPeriod_ms { get { return _transitionOnPeriod_ms; } set { _transitionOnPeriod_ms = value; } }

  public uint transitionOffPeriod_ms { get { return _transitionOffPeriod_ms; } set { _transitionOffPeriod_ms = value; } }

  public int offset { get { return _offset; } set { _offset = value; } }

  public float relativeToX { get { return _relativeToX; } set { _relativeToX = value; } }

  public float relativeToY { get { return _relativeToY; } set { _relativeToY = value; } }

  public bool rotate { get { return _rotate; } set { _rotate = value; } }

  public Anki.Vector.WhichCubeLEDs whichLEDs { get { return _whichLEDs; } set { _whichLEDs = value; } }

  public Anki.Vector.MakeRelativeMode makeRelative { get { return _makeRelative; } set { _makeRelative = value; } }

  public byte turnOffUnspecifiedLEDs { get { return _turnOffUnspecifiedLEDs; } set { _turnOffUnspecifiedLEDs = value; } }


  /**** Constructors ****/

  public SetActiveObjectLEDs()
  {
  }

  public SetActiveObjectLEDs(uint objectID,
    uint onColor,
    uint offColor,
    uint onPeriod_ms,
    uint offPeriod_ms,
    uint transitionOnPeriod_ms,
    uint transitionOffPeriod_ms,
    int offset,
    float relativeToX,
    float relativeToY,
    bool rotate,
    Anki.Vector.WhichCubeLEDs whichLEDs,
    Anki.Vector.MakeRelativeMode makeRelative,
    byte turnOffUnspecifiedLEDs)
  {
    this.objectID = objectID;
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
    this.relativeToX = relativeToX;
    this.relativeToY = relativeToY;
    this.rotate = rotate;
    this.whichLEDs = whichLEDs;
    this.makeRelative = makeRelative;
    this.turnOffUnspecifiedLEDs = turnOffUnspecifiedLEDs;
  }

  public SetActiveObjectLEDs(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetActiveObjectLEDs(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetActiveObjectLEDs Initialize(uint objectID,
    uint onColor,
    uint offColor,
    uint onPeriod_ms,
    uint offPeriod_ms,
    uint transitionOnPeriod_ms,
    uint transitionOffPeriod_ms,
    int offset,
    float relativeToX,
    float relativeToY,
    bool rotate,
    Anki.Vector.WhichCubeLEDs whichLEDs,
    Anki.Vector.MakeRelativeMode makeRelative,
    byte turnOffUnspecifiedLEDs)
  {
    this.objectID = objectID;
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
    this.relativeToX = relativeToX;
    this.relativeToY = relativeToY;
    this.rotate = rotate;
    this.whichLEDs = whichLEDs;
    this.makeRelative = makeRelative;
    this.turnOffUnspecifiedLEDs = turnOffUnspecifiedLEDs;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _objectID = reader.ReadUInt32();
    _onColor = reader.ReadUInt32();
    _offColor = reader.ReadUInt32();
    _onPeriod_ms = reader.ReadUInt32();
    _offPeriod_ms = reader.ReadUInt32();
    _transitionOnPeriod_ms = reader.ReadUInt32();
    _transitionOffPeriod_ms = reader.ReadUInt32();
    _offset = reader.ReadInt32();
    _relativeToX = reader.ReadSingle();
    _relativeToY = reader.ReadSingle();
    _rotate = reader.ReadBoolean();
    _whichLEDs = (Anki.Vector.WhichCubeLEDs)reader.ReadByte();
    _makeRelative = (Anki.Vector.MakeRelativeMode)reader.ReadByte();
    _turnOffUnspecifiedLEDs = reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_objectID);
    writer.Write((uint)_onColor);
    writer.Write((uint)_offColor);
    writer.Write((uint)_onPeriod_ms);
    writer.Write((uint)_offPeriod_ms);
    writer.Write((uint)_transitionOnPeriod_ms);
    writer.Write((uint)_transitionOffPeriod_ms);
    writer.Write((int)_offset);
    writer.Write((float)_relativeToX);
    writer.Write((float)_relativeToY);
    writer.Write((bool)_rotate);
    writer.Write((byte)_whichLEDs);
    writer.Write((byte)_makeRelative);
    writer.Write((byte)_turnOffUnspecifiedLEDs);
  }

  public int Size
  {
    get {
      return 44;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetActiveObjectLEDs a, SetActiveObjectLEDs b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetActiveObjectLEDs a, SetActiveObjectLEDs b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetActiveObjectLEDs);
  }

  public bool Equals(SetActiveObjectLEDs p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._objectID.Equals(p._objectID)
      && this._onColor.Equals(p._onColor)
      && this._offColor.Equals(p._offColor)
      && this._onPeriod_ms.Equals(p._onPeriod_ms)
      && this._offPeriod_ms.Equals(p._offPeriod_ms)
      && this._transitionOnPeriod_ms.Equals(p._transitionOnPeriod_ms)
      && this._transitionOffPeriod_ms.Equals(p._transitionOffPeriod_ms)
      && this._offset.Equals(p._offset)
      && this._relativeToX.Equals(p._relativeToX)
      && this._relativeToY.Equals(p._relativeToY)
      && this._rotate.Equals(p._rotate)
      && this._whichLEDs.Equals(p._whichLEDs)
      && this._makeRelative.Equals(p._makeRelative)
      && this._turnOffUnspecifiedLEDs.Equals(p._turnOffUnspecifiedLEDs);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._objectID.GetHashCode();
      hash = hash * 23 + this._onColor.GetHashCode();
      hash = hash * 23 + this._offColor.GetHashCode();
      hash = hash * 23 + this._onPeriod_ms.GetHashCode();
      hash = hash * 23 + this._offPeriod_ms.GetHashCode();
      hash = hash * 23 + this._transitionOnPeriod_ms.GetHashCode();
      hash = hash * 23 + this._transitionOffPeriod_ms.GetHashCode();
      hash = hash * 23 + this._offset.GetHashCode();
      hash = hash * 23 + this._relativeToX.GetHashCode();
      hash = hash * 23 + this._relativeToY.GetHashCode();
      hash = hash * 23 + this._rotate.GetHashCode();
      hash = hash * 23 + this._whichLEDs.GetHashCode();
      hash = hash * 23 + this._makeRelative.GetHashCode();
      hash = hash * 23 + this._turnOffUnspecifiedLEDs.GetHashCode();
      return hash;
    }
  }
}

public partial class SetAllActiveObjectLEDs
{
  private uint _objectID; // uint_32
  private uint[] _onColor; // uint_32[4]
  private uint[] _offColor; // uint_32[4]
  private uint[] _onPeriod_ms; // uint_32[4]
  private uint[] _offPeriod_ms; // uint_32[4]
  private uint[] _transitionOnPeriod_ms; // uint_32[4]
  private uint[] _transitionOffPeriod_ms; // uint_32[4]
  private int[] _offset; // int_32[4]
  private float _relativeToX; // float_32
  private float _relativeToY; // float_32
  private bool _rotate = false; // bool
  private Anki.Vector.MakeRelativeMode _makeRelative; // MakeRelativeMode

  public uint objectID { get { return _objectID; } set { _objectID = value; } }

  public uint[] onColor
  {
    get {
      return _onColor;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("onColor fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("onColor fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _onColor = value;
    }
  }

  public uint[] offColor
  {
    get {
      return _offColor;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offColor fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("offColor fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _offColor = value;
    }
  }

  public uint[] onPeriod_ms
  {
    get {
      return _onPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("onPeriod_ms fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("onPeriod_ms fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _onPeriod_ms = value;
    }
  }

  public uint[] offPeriod_ms
  {
    get {
      return _offPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offPeriod_ms fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("offPeriod_ms fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _offPeriod_ms = value;
    }
  }

  public uint[] transitionOnPeriod_ms
  {
    get {
      return _transitionOnPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("transitionOnPeriod_ms fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("transitionOnPeriod_ms fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _transitionOnPeriod_ms = value;
    }
  }

  public uint[] transitionOffPeriod_ms
  {
    get {
      return _transitionOffPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("transitionOffPeriod_ms fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("transitionOffPeriod_ms fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _transitionOffPeriod_ms = value;
    }
  }

  public int[] offset
  {
    get {
      return _offset;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offset fixed-length array is null. Must have a length of 4.", "value");
      }
      if (value.Length != 4) {
        throw new System.ArgumentException("offset fixed-length array is the wrong size. Must have a length of 4.", "value");
      }
      _offset = value;
    }
  }

  public float relativeToX { get { return _relativeToX; } set { _relativeToX = value; } }

  public float relativeToY { get { return _relativeToY; } set { _relativeToY = value; } }

  public bool rotate { get { return _rotate; } set { _rotate = value; } }

  public Anki.Vector.MakeRelativeMode makeRelative { get { return _makeRelative; } set { _makeRelative = value; } }


  /**** Constructors ****/

  public SetAllActiveObjectLEDs()
  {
    this.onColor = new uint[4];
    this.offColor = new uint[4];
    this.onPeriod_ms = new uint[4];
    this.offPeriod_ms = new uint[4];
    this.transitionOnPeriod_ms = new uint[4];
    this.transitionOffPeriod_ms = new uint[4];
    this.offset = new int[4];
  }

  public SetAllActiveObjectLEDs(uint objectID,
    uint[] onColor,
    uint[] offColor,
    uint[] onPeriod_ms,
    uint[] offPeriod_ms,
    uint[] transitionOnPeriod_ms,
    uint[] transitionOffPeriod_ms,
    int[] offset,
    float relativeToX,
    float relativeToY,
    bool rotate,
    Anki.Vector.MakeRelativeMode makeRelative)
  {
    this.objectID = objectID;
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
    this.relativeToX = relativeToX;
    this.relativeToY = relativeToY;
    this.rotate = rotate;
    this.makeRelative = makeRelative;
  }

  public SetAllActiveObjectLEDs(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetAllActiveObjectLEDs(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetAllActiveObjectLEDs Initialize(uint objectID,
    uint[] onColor,
    uint[] offColor,
    uint[] onPeriod_ms,
    uint[] offPeriod_ms,
    uint[] transitionOnPeriod_ms,
    uint[] transitionOffPeriod_ms,
    int[] offset,
    float relativeToX,
    float relativeToY,
    bool rotate,
    Anki.Vector.MakeRelativeMode makeRelative)
  {
    this.objectID = objectID;
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
    this.relativeToX = relativeToX;
    this.relativeToY = relativeToY;
    this.rotate = rotate;
    this.makeRelative = makeRelative;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _objectID = reader.ReadUInt32();
    _onColor = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _onColor[i] = reader.ReadUInt32();
    }
    _offColor = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _offColor[i] = reader.ReadUInt32();
    }
    _onPeriod_ms = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _onPeriod_ms[i] = reader.ReadUInt32();
    }
    _offPeriod_ms = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _offPeriod_ms[i] = reader.ReadUInt32();
    }
    _transitionOnPeriod_ms = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _transitionOnPeriod_ms[i] = reader.ReadUInt32();
    }
    _transitionOffPeriod_ms = new uint[4];
    for (int i = 0; i < 4; ++i) {
      _transitionOffPeriod_ms[i] = reader.ReadUInt32();
    }
    _offset = new int[4];
    for (int i = 0; i < 4; ++i) {
      _offset[i] = reader.ReadInt32();
    }
    _relativeToX = reader.ReadSingle();
    _relativeToY = reader.ReadSingle();
    _rotate = reader.ReadBoolean();
    _makeRelative = (Anki.Vector.MakeRelativeMode)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_objectID);
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_onColor[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_offColor[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_onPeriod_ms[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_offPeriod_ms[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_transitionOnPeriod_ms[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((uint)_transitionOffPeriod_ms[i]);
    }
    for (int i = 0; i < 4; ++i) {
      writer.Write((int)_offset[i]);
    }
    writer.Write((float)_relativeToX);
    writer.Write((float)_relativeToY);
    writer.Write((bool)_rotate);
    writer.Write((byte)_makeRelative);
  }

  public int Size
  {
    get {
      return 126;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetAllActiveObjectLEDs a, SetAllActiveObjectLEDs b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetAllActiveObjectLEDs a, SetAllActiveObjectLEDs b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetAllActiveObjectLEDs);
  }

  public bool Equals(SetAllActiveObjectLEDs p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._objectID.Equals(p._objectID)
      && ArrayEquals<uint>(this._onColor,p._onColor)
      && ArrayEquals<uint>(this._offColor,p._offColor)
      && ArrayEquals<uint>(this._onPeriod_ms,p._onPeriod_ms)
      && ArrayEquals<uint>(this._offPeriod_ms,p._offPeriod_ms)
      && ArrayEquals<uint>(this._transitionOnPeriod_ms,p._transitionOnPeriod_ms)
      && ArrayEquals<uint>(this._transitionOffPeriod_ms,p._transitionOffPeriod_ms)
      && ArrayEquals<int>(this._offset,p._offset)
      && this._relativeToX.Equals(p._relativeToX)
      && this._relativeToY.Equals(p._relativeToY)
      && this._rotate.Equals(p._rotate)
      && this._makeRelative.Equals(p._makeRelative);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._objectID.GetHashCode();
      hash = hash * 23 + this._relativeToX.GetHashCode();
      hash = hash * 23 + this._relativeToY.GetHashCode();
      hash = hash * 23 + this._rotate.GetHashCode();
      hash = hash * 23 + this._makeRelative.GetHashCode();
      return hash;
    }
  }
}

public partial class SetBackpackLEDs
{
  private uint[] _onColor; // uint_32[3]
  private uint[] _offColor; // uint_32[3]
  private uint[] _onPeriod_ms; // uint_32[3]
  private uint[] _offPeriod_ms; // uint_32[3]
  private uint[] _transitionOnPeriod_ms; // uint_32[3]
  private uint[] _transitionOffPeriod_ms; // uint_32[3]
  private int[] _offset; // int_32[3]

  public uint[] onColor
  {
    get {
      return _onColor;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("onColor fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("onColor fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _onColor = value;
    }
  }

  public uint[] offColor
  {
    get {
      return _offColor;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offColor fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("offColor fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _offColor = value;
    }
  }

  public uint[] onPeriod_ms
  {
    get {
      return _onPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("onPeriod_ms fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("onPeriod_ms fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _onPeriod_ms = value;
    }
  }

  public uint[] offPeriod_ms
  {
    get {
      return _offPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offPeriod_ms fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("offPeriod_ms fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _offPeriod_ms = value;
    }
  }

  public uint[] transitionOnPeriod_ms
  {
    get {
      return _transitionOnPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("transitionOnPeriod_ms fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("transitionOnPeriod_ms fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _transitionOnPeriod_ms = value;
    }
  }

  public uint[] transitionOffPeriod_ms
  {
    get {
      return _transitionOffPeriod_ms;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("transitionOffPeriod_ms fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("transitionOffPeriod_ms fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _transitionOffPeriod_ms = value;
    }
  }

  public int[] offset
  {
    get {
      return _offset;
    }
    set {
      if (value == null) {
        throw new System.ArgumentException("offset fixed-length array is null. Must have a length of 3.", "value");
      }
      if (value.Length != 3) {
        throw new System.ArgumentException("offset fixed-length array is the wrong size. Must have a length of 3.", "value");
      }
      _offset = value;
    }
  }


  /**** Constructors ****/

  public SetBackpackLEDs()
  {
    this.onColor = new uint[3];
    this.offColor = new uint[3];
    this.onPeriod_ms = new uint[3];
    this.offPeriod_ms = new uint[3];
    this.transitionOnPeriod_ms = new uint[3];
    this.transitionOffPeriod_ms = new uint[3];
    this.offset = new int[3];
  }

  public SetBackpackLEDs(uint[] onColor,
    uint[] offColor,
    uint[] onPeriod_ms,
    uint[] offPeriod_ms,
    uint[] transitionOnPeriod_ms,
    uint[] transitionOffPeriod_ms,
    int[] offset)
  {
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
  }

  public SetBackpackLEDs(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetBackpackLEDs(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetBackpackLEDs Initialize(uint[] onColor,
    uint[] offColor,
    uint[] onPeriod_ms,
    uint[] offPeriod_ms,
    uint[] transitionOnPeriod_ms,
    uint[] transitionOffPeriod_ms,
    int[] offset)
  {
    this.onColor = onColor;
    this.offColor = offColor;
    this.onPeriod_ms = onPeriod_ms;
    this.offPeriod_ms = offPeriod_ms;
    this.transitionOnPeriod_ms = transitionOnPeriod_ms;
    this.transitionOffPeriod_ms = transitionOffPeriod_ms;
    this.offset = offset;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _onColor = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _onColor[i] = reader.ReadUInt32();
    }
    _offColor = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _offColor[i] = reader.ReadUInt32();
    }
    _onPeriod_ms = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _onPeriod_ms[i] = reader.ReadUInt32();
    }
    _offPeriod_ms = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _offPeriod_ms[i] = reader.ReadUInt32();
    }
    _transitionOnPeriod_ms = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _transitionOnPeriod_ms[i] = reader.ReadUInt32();
    }
    _transitionOffPeriod_ms = new uint[3];
    for (int i = 0; i < 3; ++i) {
      _transitionOffPeriod_ms[i] = reader.ReadUInt32();
    }
    _offset = new int[3];
    for (int i = 0; i < 3; ++i) {
      _offset[i] = reader.ReadInt32();
    }
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_onColor[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_offColor[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_onPeriod_ms[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_offPeriod_ms[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_transitionOnPeriod_ms[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((uint)_transitionOffPeriod_ms[i]);
    }
    for (int i = 0; i < 3; ++i) {
      writer.Write((int)_offset[i]);
    }
  }

  public int Size
  {
    get {
      return 84;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetBackpackLEDs a, SetBackpackLEDs b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetBackpackLEDs a, SetBackpackLEDs b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetBackpackLEDs);
  }

  public bool Equals(SetBackpackLEDs p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return ArrayEquals<uint>(this._onColor,p._onColor)
      && ArrayEquals<uint>(this._offColor,p._offColor)
      && ArrayEquals<uint>(this._onPeriod_ms,p._onPeriod_ms)
      && ArrayEquals<uint>(this._offPeriod_ms,p._offPeriod_ms)
      && ArrayEquals<uint>(this._transitionOnPeriod_ms,p._transitionOnPeriod_ms)
      && ArrayEquals<uint>(this._transitionOffPeriod_ms,p._transitionOffPeriod_ms)
      && ArrayEquals<int>(this._offset,p._offset);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class EnableLightStates
{
  private bool _enable; // bool
  private int _objectID = -1; // int_32

  public bool enable { get { return _enable; } set { _enable = value; } }

  public int objectID { get { return _objectID; } set { _objectID = value; } }


  /**** Constructors ****/

  public EnableLightStates()
  {
  }

  public EnableLightStates(bool enable,
    int objectID)
  {
    this.enable = enable;
    this.objectID = objectID;
  }

  public EnableLightStates(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public EnableLightStates(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public EnableLightStates Initialize(bool enable,
    int objectID)
  {
    this.enable = enable;
    this.objectID = objectID;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
    _objectID = reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
    writer.Write((int)_objectID);
  }

  public int Size
  {
    get {
      return 5;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(EnableLightStates a, EnableLightStates b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(EnableLightStates a, EnableLightStates b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as EnableLightStates);
  }

  public bool Equals(EnableLightStates p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable)
      && this._objectID.Equals(p._objectID);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      hash = hash * 23 + this._objectID.GetHashCode();
      return hash;
    }
  }
}

public partial class PlayCubeAnim
{
  private uint _objectID; // uint_32
  private Anki.Vector.CubeAnimationTrigger _trigger; // CubeAnimationTrigger

  public uint objectID { get { return _objectID; } set { _objectID = value; } }

  public Anki.Vector.CubeAnimationTrigger trigger { get { return _trigger; } set { _trigger = value; } }


  /**** Constructors ****/

  public PlayCubeAnim()
  {
  }

  public PlayCubeAnim(uint objectID,
    Anki.Vector.CubeAnimationTrigger trigger)
  {
    this.objectID = objectID;
    this.trigger = trigger;
  }

  public PlayCubeAnim(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public PlayCubeAnim(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public PlayCubeAnim Initialize(uint objectID,
    Anki.Vector.CubeAnimationTrigger trigger)
  {
    this.objectID = objectID;
    this.trigger = trigger;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _objectID = reader.ReadUInt32();
    _trigger = (Anki.Vector.CubeAnimationTrigger)reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_objectID);
    writer.Write((int)_trigger);
  }

  public int Size
  {
    get {
      return 8;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(PlayCubeAnim a, PlayCubeAnim b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(PlayCubeAnim a, PlayCubeAnim b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as PlayCubeAnim);
  }

  public bool Equals(PlayCubeAnim p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._objectID.Equals(p._objectID)
      && this._trigger.Equals(p._trigger);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._objectID.GetHashCode();
      hash = hash * 23 + this._trigger.GetHashCode();
      return hash;
    }
  }
}

public partial class StopCubeAnim
{
  private uint _objectID; // uint_32
  private Anki.Vector.CubeAnimationTrigger _trigger; // CubeAnimationTrigger

  public uint objectID { get { return _objectID; } set { _objectID = value; } }

  public Anki.Vector.CubeAnimationTrigger trigger { get { return _trigger; } set { _trigger = value; } }


  /**** Constructors ****/

  public StopCubeAnim()
  {
  }

  public StopCubeAnim(uint objectID,
    Anki.Vector.CubeAnimationTrigger trigger)
  {
    this.objectID = objectID;
    this.trigger = trigger;
  }

  public StopCubeAnim(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public StopCubeAnim(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public StopCubeAnim Initialize(uint objectID,
    Anki.Vector.CubeAnimationTrigger trigger)
  {
    this.objectID = objectID;
    this.trigger = trigger;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _objectID = reader.ReadUInt32();
    _trigger = (Anki.Vector.CubeAnimationTrigger)reader.ReadInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_objectID);
    writer.Write((int)_trigger);
  }

  public int Size
  {
    get {
      return 8;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(StopCubeAnim a, StopCubeAnim b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(StopCubeAnim a, StopCubeAnim b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as StopCubeAnim);
  }

  public bool Equals(StopCubeAnim p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._objectID.Equals(p._objectID)
      && this._trigger.Equals(p._trigger);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._objectID.GetHashCode();
      hash = hash * 23 + this._trigger.GetHashCode();
      return hash;
    }
  }
}

public partial class SetOnboardingStage
{
  private Anki.Vector.OnboardingStages _stage; // OnboardingStages

  public Anki.Vector.OnboardingStages stage { get { return _stage; } set { _stage = value; } }


  /**** Constructors ****/

  public SetOnboardingStage()
  {
  }

  public SetOnboardingStage(Anki.Vector.OnboardingStages stage)
  {
    this.stage = stage;
  }

  public SetOnboardingStage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetOnboardingStage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetOnboardingStage Initialize(Anki.Vector.OnboardingStages stage)
  {
    this.stage = stage;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _stage = (Anki.Vector.OnboardingStages)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_stage);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetOnboardingStage a, SetOnboardingStage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetOnboardingStage a, SetOnboardingStage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetOnboardingStage);
  }

  public bool Equals(SetOnboardingStage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._stage.Equals(p._stage);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._stage.GetHashCode();
      return hash;
    }
  }
}

public partial class GetEmotions
{
  /**** Constructors ****/

  public GetEmotions()
  {
  }

  public GetEmotions(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public GetEmotions(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class SetEmotion
{
  private Anki.Vector.EmotionType _emotionType; // EmotionType
  private float _newVal; // float_32

  public Anki.Vector.EmotionType emotionType { get { return _emotionType; } set { _emotionType = value; } }

  public float newVal { get { return _newVal; } set { _newVal = value; } }


  /**** Constructors ****/

  public SetEmotion()
  {
  }

  public SetEmotion(Anki.Vector.EmotionType emotionType,
    float newVal)
  {
    this.emotionType = emotionType;
    this.newVal = newVal;
  }

  public SetEmotion(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetEmotion(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetEmotion Initialize(Anki.Vector.EmotionType emotionType,
    float newVal)
  {
    this.emotionType = emotionType;
    this.newVal = newVal;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _emotionType = (Anki.Vector.EmotionType)reader.ReadByte();
    _newVal = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_emotionType);
    writer.Write((float)_newVal);
  }

  public int Size
  {
    get {
      return 5;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetEmotion a, SetEmotion b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetEmotion a, SetEmotion b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetEmotion);
  }

  public bool Equals(SetEmotion p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._emotionType.Equals(p._emotionType)
      && this._newVal.Equals(p._newVal);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._emotionType.GetHashCode();
      hash = hash * 23 + this._newVal.GetHashCode();
      return hash;
    }
  }
}

public partial class AddToEmotion
{
  private Anki.Vector.EmotionType _emotionType; // EmotionType
  private float _deltaVal; // float_32
  private string _uniqueIdString; // string[uint_8]

  public Anki.Vector.EmotionType emotionType { get { return _emotionType; } set { _emotionType = value; } }

  public float deltaVal { get { return _deltaVal; } set { _deltaVal = value; } }

  public string uniqueIdString
  {
    get {
      return _uniqueIdString;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("uniqueIdString string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _uniqueIdString = value;
    }
  }


  /**** Constructors ****/

  public AddToEmotion()
  {
  }

  public AddToEmotion(Anki.Vector.EmotionType emotionType,
    float deltaVal,
    string uniqueIdString)
  {
    this.emotionType = emotionType;
    this.deltaVal = deltaVal;
    this.uniqueIdString = uniqueIdString;
  }

  public AddToEmotion(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public AddToEmotion(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public AddToEmotion Initialize(Anki.Vector.EmotionType emotionType,
    float deltaVal,
    string uniqueIdString)
  {
    this.emotionType = emotionType;
    this.deltaVal = deltaVal;
    this.uniqueIdString = uniqueIdString;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _emotionType = (Anki.Vector.EmotionType)reader.ReadByte();
    _deltaVal = reader.ReadSingle();
    int _uniqueIdString_length = (int)reader.ReadByte();
    byte[] _uniqueIdString_bytes = reader.ReadBytes(_uniqueIdString_length);
    _uniqueIdString = System.Text.Encoding.UTF8.GetString(_uniqueIdString_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)_emotionType);
    writer.Write((float)_deltaVal);
    if (_uniqueIdString != null) {
      byte[] _uniqueIdString_bytes = System.Text.Encoding.UTF8.GetBytes(_uniqueIdString);
      writer.Write((byte)_uniqueIdString_bytes.Length);
      writer.Write(_uniqueIdString_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // EmotionType
      result += 4; // float_32
      result += 1; // uint_8
      if (uniqueIdString != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(uniqueIdString);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(AddToEmotion a, AddToEmotion b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(AddToEmotion a, AddToEmotion b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as AddToEmotion);
  }

  public bool Equals(AddToEmotion p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._emotionType.Equals(p._emotionType)
      && this._deltaVal.Equals(p._deltaVal)
      && this._uniqueIdString.Equals(p._uniqueIdString);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._emotionType.GetHashCode();
      hash = hash * 23 + this._deltaVal.GetHashCode();
      return hash;
    }
  }
}

public partial class TriggerEmotionEvent
{
  private string _emotionEventName; // string[uint_8]

  public string emotionEventName
  {
    get {
      return _emotionEventName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("emotionEventName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _emotionEventName = value;
    }
  }


  /**** Constructors ****/

  public TriggerEmotionEvent()
  {
  }

  public TriggerEmotionEvent(string emotionEventName)
  {
    this.emotionEventName = emotionEventName;
  }

  public TriggerEmotionEvent(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public TriggerEmotionEvent(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public TriggerEmotionEvent Initialize(string emotionEventName)
  {
    this.emotionEventName = emotionEventName;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _emotionEventName_length = (int)reader.ReadByte();
    byte[] _emotionEventName_bytes = reader.ReadBytes(_emotionEventName_length);
    _emotionEventName = System.Text.Encoding.UTF8.GetString(_emotionEventName_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_emotionEventName != null) {
      byte[] _emotionEventName_bytes = System.Text.Encoding.UTF8.GetBytes(_emotionEventName);
      writer.Write((byte)_emotionEventName_bytes.Length);
      writer.Write(_emotionEventName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (emotionEventName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(emotionEventName);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(TriggerEmotionEvent a, TriggerEmotionEvent b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(TriggerEmotionEvent a, TriggerEmotionEvent b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as TriggerEmotionEvent);
  }

  public bool Equals(TriggerEmotionEvent p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._emotionEventName.Equals(p._emotionEventName);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public class MoodMessageUnion {
  public enum Tag {
    GetEmotions,               // 0
    SetEmotion,                // 1
    AddToEmotion,              // 2
    TriggerEmotionEvent,       // 3
    INVALID              = 255
  };
  
  private Tag _tag = Tag.INVALID;

  public Tag GetTag() { return _tag; }

  private object _state = null;

  public object GetState() { return _state; }

  public Anki.Vector.ExternalInterface.GetEmotions GetEmotions
  {
    get {
      if (_tag != Tag.GetEmotions) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GetEmotions\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GetEmotions)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GetEmotions : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetEmotion SetEmotion
  {
    get {
      if (_tag != Tag.SetEmotion) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetEmotion\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetEmotion)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetEmotion : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.AddToEmotion AddToEmotion
  {
    get {
      if (_tag != Tag.AddToEmotion) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AddToEmotion\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.AddToEmotion)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AddToEmotion : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TriggerEmotionEvent TriggerEmotionEvent
  {
    get {
      if (_tag != Tag.TriggerEmotionEvent) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TriggerEmotionEvent\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TriggerEmotionEvent)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TriggerEmotionEvent : Tag.INVALID;
      _state = value;
    }
  }

  public MoodMessageUnion Initialize<T>(T state)
  {
    _state = state;
    if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GetEmotions))
    {
      _tag = Tag.GetEmotions;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetEmotion))
    {
      _tag = Tag.SetEmotion;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.AddToEmotion))
    {
      _tag = Tag.AddToEmotion;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TriggerEmotionEvent))
    {
      _tag = Tag.TriggerEmotionEvent;
    }
    else
    {
      _state = null;
      _tag = Tag.INVALID;
    }

    return this;
  }

  /**** Constructors ****/

  public MoodMessageUnion()
  {
  }

  public MoodMessageUnion(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public MoodMessageUnion(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    Tag newTag = (Tag)reader.ReadByte();
    switch(newTag) {
    case Tag.GetEmotions:
      GetEmotions = new Anki.Vector.ExternalInterface.GetEmotions(reader);
      break;
    case Tag.SetEmotion:
      SetEmotion = new Anki.Vector.ExternalInterface.SetEmotion(reader);
      break;
    case Tag.AddToEmotion:
      AddToEmotion = new Anki.Vector.ExternalInterface.AddToEmotion(reader);
      break;
    case Tag.TriggerEmotionEvent:
      TriggerEmotionEvent = new Anki.Vector.ExternalInterface.TriggerEmotionEvent(reader);
      break;
    default:
      break;

    }
    _tag = newTag;
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)GetTag());
    switch(GetTag()) {
    case Tag.GetEmotions:
      if (GetEmotions == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GetEmotions.Pack(writer);
      break;
    case Tag.SetEmotion:
      if (SetEmotion == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetEmotion.Pack(writer);
      break;
    case Tag.AddToEmotion:
      if (AddToEmotion == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AddToEmotion.Pack(writer);
      break;
    case Tag.TriggerEmotionEvent:
      if (TriggerEmotionEvent == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TriggerEmotionEvent.Pack(writer);
      break;
    default:
      break;
    }
  }

  public int Size
  {
    get {
      int result = 1; // tag = byte
      switch(GetTag()) {
      case Tag.GetEmotions:
        if (GetEmotions == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GetEmotions.Size;
        break;
      case Tag.SetEmotion:
        if (SetEmotion == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetEmotion.Size;
        break;
      case Tag.AddToEmotion:
        if (AddToEmotion == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AddToEmotion.Size;
        break;
      case Tag.TriggerEmotionEvent:
        if (TriggerEmotionEvent == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TriggerEmotionEvent.Size;
        break;
      default:
        // Just tag size
        break;
      }
      return result;
    }
  }

  public static bool operator ==(MoodMessageUnion a, MoodMessageUnion b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(MoodMessageUnion a, MoodMessageUnion b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as MoodMessageUnion);
  }

  public bool Equals(MoodMessageUnion p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return (_tag == p._tag && _state.Equals(p._state));
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._tag.GetHashCode();
      hash = hash * 23 + this._state.GetHashCode();
      return hash;
    }
  }
}

public partial class MoodMessage
{
  private Anki.Vector.ExternalInterface.MoodMessageUnion _MoodMessageUnion; // MoodMessageUnion

  public Anki.Vector.ExternalInterface.MoodMessageUnion MoodMessageUnion
  {
    get {
      return _MoodMessageUnion;
    }
    set {
      if (value == null) {
        throw new System.ArgumentNullException("MoodMessageUnion cannot be null.", "value");
      }
      _MoodMessageUnion = value;
    }
  }


  /**** Constructors ****/

  public MoodMessage()
  {
    this.MoodMessageUnion = new Anki.Vector.ExternalInterface.MoodMessageUnion();
  }

  public MoodMessage(Anki.Vector.ExternalInterface.MoodMessageUnion MoodMessageUnion)
  {
    this.MoodMessageUnion = MoodMessageUnion;
  }

  public MoodMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public MoodMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public MoodMessage Initialize(Anki.Vector.ExternalInterface.MoodMessageUnion MoodMessageUnion)
  {
    this.MoodMessageUnion = MoodMessageUnion;
    return this;
  }

  public MoodMessage Initialize<T0>(T0 MoodMessageUnionState)
  {
    this.MoodMessageUnion.Initialize<T0>(MoodMessageUnionState);
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _MoodMessageUnion = new Anki.Vector.ExternalInterface.MoodMessageUnion(reader);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    _MoodMessageUnion.Pack(writer);
  }

  public int Size
  {
    get {
      int result = 0;
      result += MoodMessageUnion.Size;
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(MoodMessage a, MoodMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(MoodMessage a, MoodMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as MoodMessage);
  }

  public bool Equals(MoodMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._MoodMessageUnion.Equals(p._MoodMessageUnion);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._MoodMessageUnion.GetHashCode();
      return hash;
    }
  }
}

public partial class SetDebugConsoleVarMessage
{
  private string _varName; // string[uint_8]
  private string _tryValue; // string[uint_8]

  public string varName
  {
    get {
      return _varName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("varName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _varName = value;
    }
  }

  public string tryValue
  {
    get {
      return _tryValue;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("tryValue string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _tryValue = value;
    }
  }


  /**** Constructors ****/

  public SetDebugConsoleVarMessage()
  {
  }

  public SetDebugConsoleVarMessage(string varName,
    string tryValue)
  {
    this.varName = varName;
    this.tryValue = tryValue;
  }

  public SetDebugConsoleVarMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetDebugConsoleVarMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetDebugConsoleVarMessage Initialize(string varName,
    string tryValue)
  {
    this.varName = varName;
    this.tryValue = tryValue;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _varName_length = (int)reader.ReadByte();
    byte[] _varName_bytes = reader.ReadBytes(_varName_length);
    _varName = System.Text.Encoding.UTF8.GetString(_varName_bytes);
    int _tryValue_length = (int)reader.ReadByte();
    byte[] _tryValue_bytes = reader.ReadBytes(_tryValue_length);
    _tryValue = System.Text.Encoding.UTF8.GetString(_tryValue_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_varName != null) {
      byte[] _varName_bytes = System.Text.Encoding.UTF8.GetBytes(_varName);
      writer.Write((byte)_varName_bytes.Length);
      writer.Write(_varName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_tryValue != null) {
      byte[] _tryValue_bytes = System.Text.Encoding.UTF8.GetBytes(_tryValue);
      writer.Write((byte)_tryValue_bytes.Length);
      writer.Write(_tryValue_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (varName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(varName);
      }
      result += 1; // uint_8
      if (tryValue != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(tryValue);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetDebugConsoleVarMessage a, SetDebugConsoleVarMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetDebugConsoleVarMessage a, SetDebugConsoleVarMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetDebugConsoleVarMessage);
  }

  public bool Equals(SetDebugConsoleVarMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._varName.Equals(p._varName)
      && this._tryValue.Equals(p._tryValue);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class SetAnimDebugConsoleVarMessage
{
  private string _varName; // string[uint_8]
  private string _tryValue; // string[uint_8]

  public string varName
  {
    get {
      return _varName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("varName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _varName = value;
    }
  }

  public string tryValue
  {
    get {
      return _tryValue;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("tryValue string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _tryValue = value;
    }
  }


  /**** Constructors ****/

  public SetAnimDebugConsoleVarMessage()
  {
  }

  public SetAnimDebugConsoleVarMessage(string varName,
    string tryValue)
  {
    this.varName = varName;
    this.tryValue = tryValue;
  }

  public SetAnimDebugConsoleVarMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetAnimDebugConsoleVarMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetAnimDebugConsoleVarMessage Initialize(string varName,
    string tryValue)
  {
    this.varName = varName;
    this.tryValue = tryValue;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _varName_length = (int)reader.ReadByte();
    byte[] _varName_bytes = reader.ReadBytes(_varName_length);
    _varName = System.Text.Encoding.UTF8.GetString(_varName_bytes);
    int _tryValue_length = (int)reader.ReadByte();
    byte[] _tryValue_bytes = reader.ReadBytes(_tryValue_length);
    _tryValue = System.Text.Encoding.UTF8.GetString(_tryValue_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_varName != null) {
      byte[] _varName_bytes = System.Text.Encoding.UTF8.GetBytes(_varName);
      writer.Write((byte)_varName_bytes.Length);
      writer.Write(_varName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_tryValue != null) {
      byte[] _tryValue_bytes = System.Text.Encoding.UTF8.GetBytes(_tryValue);
      writer.Write((byte)_tryValue_bytes.Length);
      writer.Write(_tryValue_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (varName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(varName);
      }
      result += 1; // uint_8
      if (tryValue != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(tryValue);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetAnimDebugConsoleVarMessage a, SetAnimDebugConsoleVarMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetAnimDebugConsoleVarMessage a, SetAnimDebugConsoleVarMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetAnimDebugConsoleVarMessage);
  }

  public bool Equals(SetAnimDebugConsoleVarMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._varName.Equals(p._varName)
      && this._tryValue.Equals(p._tryValue);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class RunDebugConsoleFuncMessage
{
  private string _funcName; // string[uint_8]
  private string _funcArgs; // string[uint_8]

  public string funcName
  {
    get {
      return _funcName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("funcName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _funcName = value;
    }
  }

  public string funcArgs
  {
    get {
      return _funcArgs;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("funcArgs string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _funcArgs = value;
    }
  }


  /**** Constructors ****/

  public RunDebugConsoleFuncMessage()
  {
  }

  public RunDebugConsoleFuncMessage(string funcName,
    string funcArgs)
  {
    this.funcName = funcName;
    this.funcArgs = funcArgs;
  }

  public RunDebugConsoleFuncMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RunDebugConsoleFuncMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public RunDebugConsoleFuncMessage Initialize(string funcName,
    string funcArgs)
  {
    this.funcName = funcName;
    this.funcArgs = funcArgs;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _funcName_length = (int)reader.ReadByte();
    byte[] _funcName_bytes = reader.ReadBytes(_funcName_length);
    _funcName = System.Text.Encoding.UTF8.GetString(_funcName_bytes);
    int _funcArgs_length = (int)reader.ReadByte();
    byte[] _funcArgs_bytes = reader.ReadBytes(_funcArgs_length);
    _funcArgs = System.Text.Encoding.UTF8.GetString(_funcArgs_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_funcName != null) {
      byte[] _funcName_bytes = System.Text.Encoding.UTF8.GetBytes(_funcName);
      writer.Write((byte)_funcName_bytes.Length);
      writer.Write(_funcName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_funcArgs != null) {
      byte[] _funcArgs_bytes = System.Text.Encoding.UTF8.GetBytes(_funcArgs);
      writer.Write((byte)_funcArgs_bytes.Length);
      writer.Write(_funcArgs_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (funcName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(funcName);
      }
      result += 1; // uint_8
      if (funcArgs != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(funcArgs);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(RunDebugConsoleFuncMessage a, RunDebugConsoleFuncMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(RunDebugConsoleFuncMessage a, RunDebugConsoleFuncMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as RunDebugConsoleFuncMessage);
  }

  public bool Equals(RunDebugConsoleFuncMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._funcName.Equals(p._funcName)
      && this._funcArgs.Equals(p._funcArgs);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class RunAnimDebugConsoleFuncMessage
{
  private string _funcName; // string[uint_8]
  private string _funcArgs; // string[uint_8]

  public string funcName
  {
    get {
      return _funcName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("funcName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _funcName = value;
    }
  }

  public string funcArgs
  {
    get {
      return _funcArgs;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("funcArgs string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _funcArgs = value;
    }
  }


  /**** Constructors ****/

  public RunAnimDebugConsoleFuncMessage()
  {
  }

  public RunAnimDebugConsoleFuncMessage(string funcName,
    string funcArgs)
  {
    this.funcName = funcName;
    this.funcArgs = funcArgs;
  }

  public RunAnimDebugConsoleFuncMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RunAnimDebugConsoleFuncMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public RunAnimDebugConsoleFuncMessage Initialize(string funcName,
    string funcArgs)
  {
    this.funcName = funcName;
    this.funcArgs = funcArgs;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _funcName_length = (int)reader.ReadByte();
    byte[] _funcName_bytes = reader.ReadBytes(_funcName_length);
    _funcName = System.Text.Encoding.UTF8.GetString(_funcName_bytes);
    int _funcArgs_length = (int)reader.ReadByte();
    byte[] _funcArgs_bytes = reader.ReadBytes(_funcArgs_length);
    _funcArgs = System.Text.Encoding.UTF8.GetString(_funcArgs_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_funcName != null) {
      byte[] _funcName_bytes = System.Text.Encoding.UTF8.GetBytes(_funcName);
      writer.Write((byte)_funcName_bytes.Length);
      writer.Write(_funcName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    if (_funcArgs != null) {
      byte[] _funcArgs_bytes = System.Text.Encoding.UTF8.GetBytes(_funcArgs);
      writer.Write((byte)_funcArgs_bytes.Length);
      writer.Write(_funcArgs_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (funcName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(funcName);
      }
      result += 1; // uint_8
      if (funcArgs != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(funcArgs);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(RunAnimDebugConsoleFuncMessage a, RunAnimDebugConsoleFuncMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(RunAnimDebugConsoleFuncMessage a, RunAnimDebugConsoleFuncMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as RunAnimDebugConsoleFuncMessage);
  }

  public bool Equals(RunAnimDebugConsoleFuncMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._funcName.Equals(p._funcName)
      && this._funcArgs.Equals(p._funcArgs);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class GetDebugConsoleVarMessage
{
  private string _varName; // string[uint_8]

  public string varName
  {
    get {
      return _varName;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("varName string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _varName = value;
    }
  }


  /**** Constructors ****/

  public GetDebugConsoleVarMessage()
  {
  }

  public GetDebugConsoleVarMessage(string varName)
  {
    this.varName = varName;
  }

  public GetDebugConsoleVarMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public GetDebugConsoleVarMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public GetDebugConsoleVarMessage Initialize(string varName)
  {
    this.varName = varName;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _varName_length = (int)reader.ReadByte();
    byte[] _varName_bytes = reader.ReadBytes(_varName_length);
    _varName = System.Text.Encoding.UTF8.GetString(_varName_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_varName != null) {
      byte[] _varName_bytes = System.Text.Encoding.UTF8.GetBytes(_varName);
      writer.Write((byte)_varName_bytes.Length);
      writer.Write(_varName_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (varName != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(varName);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(GetDebugConsoleVarMessage a, GetDebugConsoleVarMessage b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(GetDebugConsoleVarMessage a, GetDebugConsoleVarMessage b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as GetDebugConsoleVarMessage);
  }

  public bool Equals(GetDebugConsoleVarMessage p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._varName.Equals(p._varName);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class GetAllDebugConsoleVarMessage
{
  /**** Constructors ****/

  public GetAllDebugConsoleVarMessage()
  {
  }

  public GetAllDebugConsoleVarMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public GetAllDebugConsoleVarMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class GetJsonDasLogsMessage
{
  /**** Constructors ****/

  public GetJsonDasLogsMessage()
  {
  }

  public GetJsonDasLogsMessage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public GetJsonDasLogsMessage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class SetEnableSpeedChooser
{
  private bool _enabled; // bool

  public bool enabled { get { return _enabled; } set { _enabled = value; } }


  /**** Constructors ****/

  public SetEnableSpeedChooser()
  {
  }

  public SetEnableSpeedChooser(bool enabled)
  {
    this.enabled = enabled;
  }

  public SetEnableSpeedChooser(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetEnableSpeedChooser(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetEnableSpeedChooser Initialize(bool enabled)
  {
    this.enabled = enabled;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enabled = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enabled);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetEnableSpeedChooser a, SetEnableSpeedChooser b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetEnableSpeedChooser a, SetEnableSpeedChooser b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetEnableSpeedChooser);
  }

  public bool Equals(SetEnableSpeedChooser p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enabled.Equals(p._enabled);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enabled.GetHashCode();
      return hash;
    }
  }
}

public partial class LogRawCliffData
{
  private uint _length_ms; // uint_32

  public uint length_ms { get { return _length_ms; } set { _length_ms = value; } }


  /**** Constructors ****/

  public LogRawCliffData()
  {
  }

  public LogRawCliffData(uint length_ms)
  {
    this.length_ms = length_ms;
  }

  public LogRawCliffData(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public LogRawCliffData(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public LogRawCliffData Initialize(uint length_ms)
  {
    this.length_ms = length_ms;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _length_ms = reader.ReadUInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_length_ms);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(LogRawCliffData a, LogRawCliffData b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(LogRawCliffData a, LogRawCliffData b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as LogRawCliffData);
  }

  public bool Equals(LogRawCliffData p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._length_ms.Equals(p._length_ms);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._length_ms.GetHashCode();
      return hash;
    }
  }
}

public partial class LogRawProxData
{
  private uint _length_ms; // uint_32

  public uint length_ms { get { return _length_ms; } set { _length_ms = value; } }


  /**** Constructors ****/

  public LogRawProxData()
  {
  }

  public LogRawProxData(uint length_ms)
  {
    this.length_ms = length_ms;
  }

  public LogRawProxData(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public LogRawProxData(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public LogRawProxData Initialize(uint length_ms)
  {
    this.length_ms = length_ms;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _length_ms = reader.ReadUInt32();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((uint)_length_ms);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(LogRawProxData a, LogRawProxData b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(LogRawProxData a, LogRawProxData b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as LogRawProxData);
  }

  public bool Equals(LogRawProxData p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._length_ms.Equals(p._length_ms);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._length_ms.GetHashCode();
      return hash;
    }
  }
}

public partial class ConnectToCube
{
  /**** Constructors ****/

  public ConnectToCube()
  {
  }

  public ConnectToCube(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ConnectToCube(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class DisconnectFromCube
{
  private float _gracePeriod_sec; // float_32

  public float gracePeriod_sec { get { return _gracePeriod_sec; } set { _gracePeriod_sec = value; } }


  /**** Constructors ****/

  public DisconnectFromCube()
  {
  }

  public DisconnectFromCube(float gracePeriod_sec)
  {
    this.gracePeriod_sec = gracePeriod_sec;
  }

  public DisconnectFromCube(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public DisconnectFromCube(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public DisconnectFromCube Initialize(float gracePeriod_sec)
  {
    this.gracePeriod_sec = gracePeriod_sec;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _gracePeriod_sec = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((float)_gracePeriod_sec);
  }

  public int Size
  {
    get {
      return 4;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(DisconnectFromCube a, DisconnectFromCube b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(DisconnectFromCube a, DisconnectFromCube b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as DisconnectFromCube);
  }

  public bool Equals(DisconnectFromCube p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._gracePeriod_sec.Equals(p._gracePeriod_sec);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._gracePeriod_sec.GetHashCode();
      return hash;
    }
  }
}

public partial class ForgetPreferredCube
{
  /**** Constructors ****/

  public ForgetPreferredCube()
  {
  }

  public ForgetPreferredCube(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ForgetPreferredCube(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class SetPreferredCube
{
  private string _factoryId; // string[uint_8]

  public string factoryId
  {
    get {
      return _factoryId;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("factoryId string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _factoryId = value;
    }
  }


  /**** Constructors ****/

  public SetPreferredCube()
  {
  }

  public SetPreferredCube(string factoryId)
  {
    this.factoryId = factoryId;
  }

  public SetPreferredCube(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetPreferredCube(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetPreferredCube Initialize(string factoryId)
  {
    this.factoryId = factoryId;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _factoryId_length = (int)reader.ReadByte();
    byte[] _factoryId_bytes = reader.ReadBytes(_factoryId_length);
    _factoryId = System.Text.Encoding.UTF8.GetString(_factoryId_bytes);
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_factoryId != null) {
      byte[] _factoryId_bytes = System.Text.Encoding.UTF8.GetBytes(_factoryId);
      writer.Write((byte)_factoryId_bytes.Length);
      writer.Write(_factoryId_bytes);
    }
    else {
      writer.Write((byte)0);
    }
  }

  public int Size
  {
    get {
      int result = 0;
      result += 1; // uint_8
      if (factoryId != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(factoryId);
      }
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetPreferredCube a, SetPreferredCube b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetPreferredCube a, SetPreferredCube b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetPreferredCube);
  }

  public bool Equals(SetPreferredCube p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._factoryId.Equals(p._factoryId);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      return hash;
    }
  }
}

public partial class SendAvailableObjects
{
  private bool _enable; // bool

  public bool enable { get { return _enable; } set { _enable = value; } }


  /**** Constructors ****/

  public SendAvailableObjects()
  {
  }

  public SendAvailableObjects(bool enable)
  {
    this.enable = enable;
  }

  public SendAvailableObjects(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SendAvailableObjects(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SendAvailableObjects Initialize(bool enable)
  {
    this.enable = enable;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enable = reader.ReadBoolean();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enable);
  }

  public int Size
  {
    get {
      return 1;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SendAvailableObjects a, SendAvailableObjects b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SendAvailableObjects a, SendAvailableObjects b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SendAvailableObjects);
  }

  public bool Equals(SendAvailableObjects p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enable.Equals(p._enable);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enable.GetHashCode();
      return hash;
    }
  }
}

public partial class SaveCalibrationImage
{
  /**** Constructors ****/

  public SaveCalibrationImage()
  {
  }

  public SaveCalibrationImage(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SaveCalibrationImage(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class ClearCalibrationImages
{
  /**** Constructors ****/

  public ClearCalibrationImages()
  {
  }

  public ClearCalibrationImages(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ClearCalibrationImages(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class ComputeCameraCalibration
{
  /**** Constructors ****/

  public ComputeCameraCalibration()
  {
  }

  public ComputeCameraCalibration(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public ComputeCameraCalibration(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public enum FileType : byte
{
  Animation = 0,
  FaceImg = 1
};

public partial class TransferFile
{
  private byte[] _fileBytes; // uint_8[uint_16]
  private ushort _filePart; // uint_16
  private ushort _numFileParts; // uint_16
  private string _filename; // string[uint_8]
  private Anki.Vector.ExternalInterface.FileType _fileType; // FileType

  public byte[] fileBytes
  {
    get {
      return _fileBytes;
    }
    set {
      if (value != null && value.Length > 65535) {
        throw new System.ArgumentException("fileBytes variable-length array is too long. Must be less than or equal to 65535.", "value");
      }
      _fileBytes = value;
    }
  }

  public ushort filePart { get { return _filePart; } set { _filePart = value; } }

  public ushort numFileParts { get { return _numFileParts; } set { _numFileParts = value; } }

  public string filename
  {
    get {
      return _filename;
    }
    set {
      if (!string.IsNullOrEmpty(value) && System.Text.Encoding.UTF8.GetByteCount(value) > 255) {
        throw new System.ArgumentException("filename string is too long. Must decode to less than or equal to 255 bytes.", "value");
      }
      _filename = value;
    }
  }

  public Anki.Vector.ExternalInterface.FileType fileType { get { return _fileType; } set { _fileType = value; } }


  /**** Constructors ****/

  public TransferFile()
  {
  }

  public TransferFile(byte[] fileBytes,
    ushort filePart,
    ushort numFileParts,
    string filename,
    Anki.Vector.ExternalInterface.FileType fileType)
  {
    this.fileBytes = fileBytes;
    this.filePart = filePart;
    this.numFileParts = numFileParts;
    this.filename = filename;
    this.fileType = fileType;
  }

  public TransferFile(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public TransferFile(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public TransferFile Initialize(byte[] fileBytes,
    ushort filePart,
    ushort numFileParts,
    string filename,
    Anki.Vector.ExternalInterface.FileType fileType)
  {
    this.fileBytes = fileBytes;
    this.filePart = filePart;
    this.numFileParts = numFileParts;
    this.filename = filename;
    this.fileType = fileType;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    int _fileBytes_length = (int)reader.ReadUInt16();
    _fileBytes = new byte[_fileBytes_length];
    for (int i = 0; i < _fileBytes_length; ++i) {
      _fileBytes[i] = reader.ReadByte();
    }
    _filePart = reader.ReadUInt16();
    _numFileParts = reader.ReadUInt16();
    int _filename_length = (int)reader.ReadByte();
    byte[] _filename_bytes = reader.ReadBytes(_filename_length);
    _filename = System.Text.Encoding.UTF8.GetString(_filename_bytes);
    _fileType = (Anki.Vector.ExternalInterface.FileType)reader.ReadByte();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    if (_fileBytes != null) {
      writer.Write((ushort)_fileBytes.Length);
      for (int i = 0; i < _fileBytes.Length; ++i) {
        writer.Write((byte)_fileBytes[i]);
      }
    }
    else {
      writer.Write((ushort)0);
    }
    writer.Write((ushort)_filePart);
    writer.Write((ushort)_numFileParts);
    if (_filename != null) {
      byte[] _filename_bytes = System.Text.Encoding.UTF8.GetBytes(_filename);
      writer.Write((byte)_filename_bytes.Length);
      writer.Write(_filename_bytes);
    }
    else {
      writer.Write((byte)0);
    }
    writer.Write((byte)_fileType);
  }

  public int Size
  {
    get {
      int result = 0;
      result += 2; // uint_16
      if (fileBytes != null) {
        result += fileBytes.Length * 1; // uint_8
      }
      result += 2; // uint_16
      result += 2; // uint_16
      result += 1; // uint_8
      if (filename != null) {
        result += System.Text.Encoding.UTF8.GetByteCount(filename);
      }
      result += 1; // FileType
      return result;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(TransferFile a, TransferFile b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(TransferFile a, TransferFile b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as TransferFile);
  }

  public bool Equals(TransferFile p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return ArrayEquals<byte>(this._fileBytes,p._fileBytes)
      && this._filePart.Equals(p._filePart)
      && this._numFileParts.Equals(p._numFileParts)
      && this._filename.Equals(p._filename)
      && this._fileType.Equals(p._fileType);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._filePart.GetHashCode();
      hash = hash * 23 + this._numFileParts.GetHashCode();
      hash = hash * 23 + this._fileType.GetHashCode();
      return hash;
    }
  }
}

public partial class SetCameraSettings
{
  private bool _enableAutoExposure; // bool
  private ushort _exposure_ms; // uint_16
  private float _gain; // float_32

  public bool enableAutoExposure { get { return _enableAutoExposure; } set { _enableAutoExposure = value; } }

  public ushort exposure_ms { get { return _exposure_ms; } set { _exposure_ms = value; } }

  public float gain { get { return _gain; } set { _gain = value; } }


  /**** Constructors ****/

  public SetCameraSettings()
  {
  }

  public SetCameraSettings(bool enableAutoExposure,
    ushort exposure_ms,
    float gain)
  {
    this.enableAutoExposure = enableAutoExposure;
    this.exposure_ms = exposure_ms;
    this.gain = gain;
  }

  public SetCameraSettings(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public SetCameraSettings(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public SetCameraSettings Initialize(bool enableAutoExposure,
    ushort exposure_ms,
    float gain)
  {
    this.enableAutoExposure = enableAutoExposure;
    this.exposure_ms = exposure_ms;
    this.gain = gain;
    return this;
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    _enableAutoExposure = reader.ReadBoolean();
    _exposure_ms = reader.ReadUInt16();
    _gain = reader.ReadSingle();
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((bool)_enableAutoExposure);
    writer.Write((ushort)_exposure_ms);
    writer.Write((float)_gain);
  }

  public int Size
  {
    get {
      return 7;
    }
  }

  public static bool ArrayEquals<T>(System.Collections.Generic.IList<T> a1, System.Collections.Generic.IList<T> a2) {
    if (System.Object.ReferenceEquals(a1, a2))
      return true;

    if (System.Object.ReferenceEquals(a1, null) || System.Object.ReferenceEquals(a2, null))
      return false;

    if (a1.Count != a2.Count)
      return false;

    for (int i = 0; i < a1.Count; i++)
    {
      if (!a1[i].Equals(a2[i])) {
        return false;
      }
    }
    return true;
  }

  public static bool operator ==(SetCameraSettings a, SetCameraSettings b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(SetCameraSettings a, SetCameraSettings b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as SetCameraSettings);
  }

  public bool Equals(SetCameraSettings p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return this._enableAutoExposure.Equals(p._enableAutoExposure)
      && this._exposure_ms.Equals(p._exposure_ms)
      && this._gain.Equals(p._gain);
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._enableAutoExposure.GetHashCode();
      hash = hash * 23 + this._exposure_ms.GetHashCode();
      hash = hash * 23 + this._gain.GetHashCode();
      return hash;
    }
  }
}

public partial class RequestRobotSettings
{
  /**** Constructors ****/

  public RequestRobotSettings()
  {
  }

  public RequestRobotSettings(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RequestRobotSettings(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public partial class RobotHistoryRequest
{
  /**** Constructors ****/

  public RobotHistoryRequest()
  {
  }

  public RobotHistoryRequest(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public RobotHistoryRequest(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
  }

  public void Pack(System.IO.Stream stream)
  {
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
  }

  public int Size
  {
    get {
      return 0;
    }
  }

}

public class MessageGameToEngine {
  public enum Tag {
    UiDeviceConnectionWrongVersion     = 0x0,  // 0
    MoveHead                           = 0x3,  // 3
    MoveLift                           = 0x4,  // 4
    DriveArc                           = 0x5,  // 5
    RobotHistoryRequest                = 0x6,  // 6
    DisplayFaceImageRGBChunk           = 0x8,  // 8
    AppIntent                          = 0x9,  // 9
    CancelFaceEnrollment               = 0xa,  // 10
    RequestEnrolledNames               = 0xb,  // 11
    UpdateEnrolledFaceByID             = 0xc,  // 12
    EraseEnrolledFaceByID              = 0xd,  // 13
    EraseAllEnrolledFaces              = 0xe,  // 14
    SetFaceToEnroll                    = 0xf,  // 15
    EnableVisionMode                   = 0x10, // 16
    RequestAvailableAnimations         = 0x11, // 17
    GotoPose                           = 0x12, // 18
    DriveStraight                      = 0x13, // 19
    TurnInPlace                        = 0x14, // 20
    SetHeadAngle                       = 0x15, // 21
    SetLiftHeight                      = 0x16, // 22
    AlignWithObject                    = 0x18, // 24
    SetLiftAngle                       = 0x19, // 25
    DeleteCustomMarkerObjects          = 0x1a, // 26
    DeleteFixedCustomObjects           = 0x1b, // 27
    UndefineAllCustomMarkerObjects     = 0x1c, // 28
    CreateFixedCustomObject            = 0x1d, // 29
    DefineCustomBox                    = 0x1e, // 30
    DefineCustomCube                   = 0x1f, // 31
    DefineCustomWall                   = 0x20, // 32
    SetMemoryMapBroadcastFrequency_sec = 0x21, // 33
    PostAudioEvent,                            // 34
    StopAllAudioEvents,                        // 35
    PostAudioGameState,                        // 36
    PostAudioSwitchState,                      // 37
    PostAudioParameter,                        // 38
    PostAudioMusicState,                       // 39
    CalibrateMotors,                           // 40
    CliffAlignToWhite,                         // 41
    FlipBlock,                                 // 42
    GotoObject,                                // 43
    MountCharger,                              // 44
    PanAndTilt,                                // 45
    PickupObject,                              // 46
    PlaceObjectOnGround,                       // 47
    PlaceObjectOnGroundHere,                   // 48
    PlaceOnObject,                             // 49
    PlaceRelObject,                            // 50
    PlayAnimation,                             // 51
    ListAnimations,                            // 52
    PlayAnimationGroup,                        // 53
    PlayAnimationTrigger,                      // 54
    PopAWheelie,                               // 55
    FacePlant,                                 // 56
    RealignWithObject,                         // 57
    RollObject,                                // 58
    SayText,                                   // 59
    SearchForNearbyObject,                     // 60
    TrackToFace,                               // 61
    TrackToObject,                             // 62
    TrackToLaserPoint,                         // 63
    TrackToPet,                                // 64
    TurnInPlaceAtSpeed,                        // 65
    TurnTowardsFace,                           // 66
    TurnTowardsImagePoint,                     // 67
    TurnTowardsLastFacePose,                   // 68
    TurnTowardsObject,                         // 69
    TurnTowardsPose,                           // 70
    VisuallyVerifyFace,                        // 71
    VisuallyVerifyObject,                      // 72
    VisuallyVerifyNoObjectAtPose,              // 73
    Wait,                                      // 74
    WaitForImages,                             // 75
    AdvertisementRegistrationMsg,              // 76
    AdvertisementMsg,                          // 77
    Ping,                                      // 78
    SetVizOrigin,                              // 79
    ImageChunk,                                // 80
    CameraCalibration,                         // 81
    IMURequest,                                // 82
    IMUTemperature,                            // 83
    StartControllerTestMode,                   // 84
    RawPWM,                                    // 85
    SetConnectionStatus,                       // 86
    SendBLEConnectionStatus,                   // 87
    SetBLEPin,                                 // 88
    WifiScanResponse,                          // 89
    WifiConnectResponse,                       // 90
    HasBleKeysResponse,                        // 91
    ActivateExperimentRequest,                 // 92
    ActivateExperimentResponse,                // 93
    ConnectToUiDevice,                         // 94
    DisconnectFromUiDevice,                    // 95
    UserLoggedIn,                              // 96
    DriveWheels,                               // 97
    EnableLiftPower,                           // 98
    EnableCliffSensor,                         // 99
    EnableStopOnCliff,                         // 100
    StopAllMotors,                             // 101
    ControllerGains,                           // 102
    RollActionParams,                          // 103
    SetMotionModelParams,                      // 104
    SetRobotVolume,                            // 105
    ForceDelocalizeRobot,                      // 106
    CancelAction,                              // 107
    CancelActionByIdTag,                       // 108
    QueueSingleAction,                         // 109
    QueueCompoundAction,                       // 110
    RedirectViz,                               // 111
    ImageRequest,                              // 112
    SaveImages,                                // 113
    EnableColorImages,                         // 114
    SaveRobotState,                            // 115
    EnableDisplay,                             // 116
    ExecuteTestPlan,                           // 117
    SelectNextObject,                          // 118
    SetRobotCarryingObject,                    // 119
    DeleteAllCustomObjects,                    // 120
    VisionWhileMoving,                         // 121
    VisionRunMode,                             // 122
    SaveFaceAlbumToFile,                       // 123
    LoadFaceAlbumFromFile,                     // 124
    SetCameraCaptureFormat,                    // 125
    SetMemoryMapRenderEnabled,                 // 126
    FakeTriggerWordDetected,                   // 127
    FakeCloudIntent,                           // 128
    FakeUserIntent,                            // 129
    ExecuteBehaviorByID,                       // 130
    SetLiftLoadTestAsActivatable,              // 131
    AbortPath,                                 // 132
    AbortAll,                                  // 133
    StartTestMode,                             // 134
    DrawPoseMarker,                            // 135
    ErasePoseMarker,                           // 136
    VisualizeQuad,                             // 137
    EraseQuad,                                 // 138
    ReadAnimationFile,                         // 139
    RequestAvailableAnimationGroups,           // 140
    PushDrivingAnimations,                     // 141
    RemoveDrivingAnimations,                   // 142
    DisplayProceduralFace,                     // 143
    SetFaceHue,                                // 144
    DisplayFaceImageBinaryChunk,               // 145
    SetActiveObjectLEDs,                       // 146
    SetAllActiveObjectLEDs,                    // 147
    SetBackpackLEDs,                           // 148
    EnableLightStates,                         // 149
    PlayCubeAnim,                              // 150
    StopCubeAnim,                              // 151
    SetOnboardingStage,                        // 152
    MoodMessage,                               // 153
    SetDebugConsoleVarMessage,                 // 154
    SetAnimDebugConsoleVarMessage,             // 155
    RunDebugConsoleFuncMessage,                // 156
    RunAnimDebugConsoleFuncMessage,            // 157
    GetDebugConsoleVarMessage,                 // 158
    GetAllDebugConsoleVarMessage,              // 159
    GetJsonDasLogsMessage,                     // 160
    SetEnableSpeedChooser,                     // 161
    LogRawCliffData,                           // 162
    LogRawProxData,                            // 163
    ConnectToCube,                             // 164
    DisconnectFromCube,                        // 165
    ForgetPreferredCube,                       // 166
    SetPreferredCube,                          // 167
    SendAvailableObjects,                      // 168
    SaveCalibrationImage,                      // 169
    ClearCalibrationImages,                    // 170
    ComputeCameraCalibration,                  // 171
    TransferFile,                              // 172
    SetCameraSettings,                         // 173
    RequestRobotSettings,                      // 174
    INVALID                            = 255
  };
  
  private Tag _tag = Tag.INVALID;

  public Tag GetTag() { return _tag; }

  private object _state = null;

  public object GetState() { return _state; }

  public Anki.Vector.ExternalInterface.UiDeviceConnectionWrongVersion UiDeviceConnectionWrongVersion
  {
    get {
      if (_tag != Tag.UiDeviceConnectionWrongVersion) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"UiDeviceConnectionWrongVersion\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.UiDeviceConnectionWrongVersion)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.UiDeviceConnectionWrongVersion : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.MoveHead MoveHead
  {
    get {
      if (_tag != Tag.MoveHead) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"MoveHead\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.MoveHead)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.MoveHead : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.MoveLift MoveLift
  {
    get {
      if (_tag != Tag.MoveLift) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"MoveLift\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.MoveLift)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.MoveLift : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DriveArc DriveArc
  {
    get {
      if (_tag != Tag.DriveArc) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DriveArc\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DriveArc)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DriveArc : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RobotHistoryRequest RobotHistoryRequest
  {
    get {
      if (_tag != Tag.RobotHistoryRequest) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RobotHistoryRequest\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RobotHistoryRequest)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RobotHistoryRequest : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DisplayFaceImageRGBChunk DisplayFaceImageRGBChunk
  {
    get {
      if (_tag != Tag.DisplayFaceImageRGBChunk) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DisplayFaceImageRGBChunk\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DisplayFaceImageRGBChunk)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DisplayFaceImageRGBChunk : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.AppIntent AppIntent
  {
    get {
      if (_tag != Tag.AppIntent) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AppIntent\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.AppIntent)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AppIntent : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CancelFaceEnrollment CancelFaceEnrollment
  {
    get {
      if (_tag != Tag.CancelFaceEnrollment) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CancelFaceEnrollment\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CancelFaceEnrollment)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CancelFaceEnrollment : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RequestEnrolledNames RequestEnrolledNames
  {
    get {
      if (_tag != Tag.RequestEnrolledNames) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RequestEnrolledNames\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RequestEnrolledNames)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RequestEnrolledNames : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.UpdateEnrolledFaceByID UpdateEnrolledFaceByID
  {
    get {
      if (_tag != Tag.UpdateEnrolledFaceByID) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"UpdateEnrolledFaceByID\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.UpdateEnrolledFaceByID)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.UpdateEnrolledFaceByID : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EraseEnrolledFaceByID EraseEnrolledFaceByID
  {
    get {
      if (_tag != Tag.EraseEnrolledFaceByID) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EraseEnrolledFaceByID\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EraseEnrolledFaceByID)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EraseEnrolledFaceByID : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EraseAllEnrolledFaces EraseAllEnrolledFaces
  {
    get {
      if (_tag != Tag.EraseAllEnrolledFaces) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EraseAllEnrolledFaces\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EraseAllEnrolledFaces)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EraseAllEnrolledFaces : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetFaceToEnroll SetFaceToEnroll
  {
    get {
      if (_tag != Tag.SetFaceToEnroll) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetFaceToEnroll\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetFaceToEnroll)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetFaceToEnroll : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableVisionMode EnableVisionMode
  {
    get {
      if (_tag != Tag.EnableVisionMode) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableVisionMode\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableVisionMode)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableVisionMode : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RequestAvailableAnimations RequestAvailableAnimations
  {
    get {
      if (_tag != Tag.RequestAvailableAnimations) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RequestAvailableAnimations\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RequestAvailableAnimations)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RequestAvailableAnimations : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.GotoPose GotoPose
  {
    get {
      if (_tag != Tag.GotoPose) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GotoPose\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GotoPose)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GotoPose : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DriveStraight DriveStraight
  {
    get {
      if (_tag != Tag.DriveStraight) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DriveStraight\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DriveStraight)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DriveStraight : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnInPlace TurnInPlace
  {
    get {
      if (_tag != Tag.TurnInPlace) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnInPlace\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnInPlace)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnInPlace : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetHeadAngle SetHeadAngle
  {
    get {
      if (_tag != Tag.SetHeadAngle) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetHeadAngle\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetHeadAngle)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetHeadAngle : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetLiftHeight SetLiftHeight
  {
    get {
      if (_tag != Tag.SetLiftHeight) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetLiftHeight\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetLiftHeight)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetLiftHeight : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.AlignWithObject AlignWithObject
  {
    get {
      if (_tag != Tag.AlignWithObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AlignWithObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.AlignWithObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AlignWithObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetLiftAngle SetLiftAngle
  {
    get {
      if (_tag != Tag.SetLiftAngle) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetLiftAngle\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetLiftAngle)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetLiftAngle : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DeleteCustomMarkerObjects DeleteCustomMarkerObjects
  {
    get {
      if (_tag != Tag.DeleteCustomMarkerObjects) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DeleteCustomMarkerObjects\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DeleteCustomMarkerObjects)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DeleteCustomMarkerObjects : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DeleteFixedCustomObjects DeleteFixedCustomObjects
  {
    get {
      if (_tag != Tag.DeleteFixedCustomObjects) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DeleteFixedCustomObjects\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DeleteFixedCustomObjects)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DeleteFixedCustomObjects : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.UndefineAllCustomMarkerObjects UndefineAllCustomMarkerObjects
  {
    get {
      if (_tag != Tag.UndefineAllCustomMarkerObjects) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"UndefineAllCustomMarkerObjects\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.UndefineAllCustomMarkerObjects)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.UndefineAllCustomMarkerObjects : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CreateFixedCustomObject CreateFixedCustomObject
  {
    get {
      if (_tag != Tag.CreateFixedCustomObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CreateFixedCustomObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CreateFixedCustomObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CreateFixedCustomObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DefineCustomBox DefineCustomBox
  {
    get {
      if (_tag != Tag.DefineCustomBox) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DefineCustomBox\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DefineCustomBox)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DefineCustomBox : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DefineCustomCube DefineCustomCube
  {
    get {
      if (_tag != Tag.DefineCustomCube) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DefineCustomCube\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DefineCustomCube)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DefineCustomCube : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DefineCustomWall DefineCustomWall
  {
    get {
      if (_tag != Tag.DefineCustomWall) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DefineCustomWall\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DefineCustomWall)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DefineCustomWall : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetMemoryMapBroadcastFrequency_sec SetMemoryMapBroadcastFrequency_sec
  {
    get {
      if (_tag != Tag.SetMemoryMapBroadcastFrequency_sec) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetMemoryMapBroadcastFrequency_sec\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetMemoryMapBroadcastFrequency_sec)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetMemoryMapBroadcastFrequency_sec : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.PostAudioEvent PostAudioEvent
  {
    get {
      if (_tag != Tag.PostAudioEvent) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PostAudioEvent\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.PostAudioEvent)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PostAudioEvent : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.StopAllAudioEvents StopAllAudioEvents
  {
    get {
      if (_tag != Tag.StopAllAudioEvents) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"StopAllAudioEvents\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.StopAllAudioEvents)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.StopAllAudioEvents : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.PostAudioGameState PostAudioGameState
  {
    get {
      if (_tag != Tag.PostAudioGameState) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PostAudioGameState\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.PostAudioGameState)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PostAudioGameState : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.PostAudioSwitchState PostAudioSwitchState
  {
    get {
      if (_tag != Tag.PostAudioSwitchState) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PostAudioSwitchState\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.PostAudioSwitchState)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PostAudioSwitchState : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.PostAudioParameter PostAudioParameter
  {
    get {
      if (_tag != Tag.PostAudioParameter) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PostAudioParameter\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.PostAudioParameter)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PostAudioParameter : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.AudioEngine.Multiplexer.PostAudioMusicState PostAudioMusicState
  {
    get {
      if (_tag != Tag.PostAudioMusicState) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PostAudioMusicState\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.AudioEngine.Multiplexer.PostAudioMusicState)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PostAudioMusicState : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CalibrateMotors CalibrateMotors
  {
    get {
      if (_tag != Tag.CalibrateMotors) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CalibrateMotors\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CalibrateMotors)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CalibrateMotors : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CliffAlignToWhite CliffAlignToWhite
  {
    get {
      if (_tag != Tag.CliffAlignToWhite) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CliffAlignToWhite\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CliffAlignToWhite)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CliffAlignToWhite : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.FlipBlock FlipBlock
  {
    get {
      if (_tag != Tag.FlipBlock) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"FlipBlock\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.FlipBlock)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.FlipBlock : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.GotoObject GotoObject
  {
    get {
      if (_tag != Tag.GotoObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GotoObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GotoObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GotoObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.MountCharger MountCharger
  {
    get {
      if (_tag != Tag.MountCharger) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"MountCharger\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.MountCharger)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.MountCharger : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PanAndTilt PanAndTilt
  {
    get {
      if (_tag != Tag.PanAndTilt) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PanAndTilt\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PanAndTilt)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PanAndTilt : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PickupObject PickupObject
  {
    get {
      if (_tag != Tag.PickupObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PickupObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PickupObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PickupObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlaceObjectOnGround PlaceObjectOnGround
  {
    get {
      if (_tag != Tag.PlaceObjectOnGround) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlaceObjectOnGround\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlaceObjectOnGround)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlaceObjectOnGround : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlaceObjectOnGroundHere PlaceObjectOnGroundHere
  {
    get {
      if (_tag != Tag.PlaceObjectOnGroundHere) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlaceObjectOnGroundHere\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlaceObjectOnGroundHere)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlaceObjectOnGroundHere : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlaceOnObject PlaceOnObject
  {
    get {
      if (_tag != Tag.PlaceOnObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlaceOnObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlaceOnObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlaceOnObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlaceRelObject PlaceRelObject
  {
    get {
      if (_tag != Tag.PlaceRelObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlaceRelObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlaceRelObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlaceRelObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlayAnimation PlayAnimation
  {
    get {
      if (_tag != Tag.PlayAnimation) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlayAnimation\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlayAnimation)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlayAnimation : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ListAnimations ListAnimations
  {
    get {
      if (_tag != Tag.ListAnimations) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ListAnimations\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ListAnimations)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ListAnimations : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlayAnimationGroup PlayAnimationGroup
  {
    get {
      if (_tag != Tag.PlayAnimationGroup) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlayAnimationGroup\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlayAnimationGroup)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlayAnimationGroup : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlayAnimationTrigger PlayAnimationTrigger
  {
    get {
      if (_tag != Tag.PlayAnimationTrigger) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlayAnimationTrigger\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlayAnimationTrigger)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlayAnimationTrigger : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PopAWheelie PopAWheelie
  {
    get {
      if (_tag != Tag.PopAWheelie) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PopAWheelie\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PopAWheelie)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PopAWheelie : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.FacePlant FacePlant
  {
    get {
      if (_tag != Tag.FacePlant) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"FacePlant\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.FacePlant)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.FacePlant : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RealignWithObject RealignWithObject
  {
    get {
      if (_tag != Tag.RealignWithObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RealignWithObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RealignWithObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RealignWithObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RollObject RollObject
  {
    get {
      if (_tag != Tag.RollObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RollObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RollObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RollObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SayText SayText
  {
    get {
      if (_tag != Tag.SayText) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SayText\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SayText)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SayText : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SearchForNearbyObject SearchForNearbyObject
  {
    get {
      if (_tag != Tag.SearchForNearbyObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SearchForNearbyObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SearchForNearbyObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SearchForNearbyObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TrackToFace TrackToFace
  {
    get {
      if (_tag != Tag.TrackToFace) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TrackToFace\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TrackToFace)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TrackToFace : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TrackToObject TrackToObject
  {
    get {
      if (_tag != Tag.TrackToObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TrackToObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TrackToObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TrackToObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TrackToLaserPoint TrackToLaserPoint
  {
    get {
      if (_tag != Tag.TrackToLaserPoint) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TrackToLaserPoint\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TrackToLaserPoint)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TrackToLaserPoint : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TrackToPet TrackToPet
  {
    get {
      if (_tag != Tag.TrackToPet) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TrackToPet\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TrackToPet)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TrackToPet : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnInPlaceAtSpeed TurnInPlaceAtSpeed
  {
    get {
      if (_tag != Tag.TurnInPlaceAtSpeed) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnInPlaceAtSpeed\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnInPlaceAtSpeed)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnInPlaceAtSpeed : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnTowardsFace TurnTowardsFace
  {
    get {
      if (_tag != Tag.TurnTowardsFace) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnTowardsFace\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnTowardsFace)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnTowardsFace : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnTowardsImagePoint TurnTowardsImagePoint
  {
    get {
      if (_tag != Tag.TurnTowardsImagePoint) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnTowardsImagePoint\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnTowardsImagePoint)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnTowardsImagePoint : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnTowardsLastFacePose TurnTowardsLastFacePose
  {
    get {
      if (_tag != Tag.TurnTowardsLastFacePose) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnTowardsLastFacePose\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnTowardsLastFacePose)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnTowardsLastFacePose : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnTowardsObject TurnTowardsObject
  {
    get {
      if (_tag != Tag.TurnTowardsObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnTowardsObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnTowardsObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnTowardsObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TurnTowardsPose TurnTowardsPose
  {
    get {
      if (_tag != Tag.TurnTowardsPose) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TurnTowardsPose\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TurnTowardsPose)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TurnTowardsPose : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisuallyVerifyFace VisuallyVerifyFace
  {
    get {
      if (_tag != Tag.VisuallyVerifyFace) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisuallyVerifyFace\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisuallyVerifyFace)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisuallyVerifyFace : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisuallyVerifyObject VisuallyVerifyObject
  {
    get {
      if (_tag != Tag.VisuallyVerifyObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisuallyVerifyObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisuallyVerifyObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisuallyVerifyObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisuallyVerifyNoObjectAtPose VisuallyVerifyNoObjectAtPose
  {
    get {
      if (_tag != Tag.VisuallyVerifyNoObjectAtPose) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisuallyVerifyNoObjectAtPose\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisuallyVerifyNoObjectAtPose)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisuallyVerifyNoObjectAtPose : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.Wait Wait
  {
    get {
      if (_tag != Tag.Wait) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"Wait\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.Wait)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.Wait : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.WaitForImages WaitForImages
  {
    get {
      if (_tag != Tag.WaitForImages) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"WaitForImages\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.WaitForImages)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.WaitForImages : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.AdvertisementRegistrationMsg AdvertisementRegistrationMsg
  {
    get {
      if (_tag != Tag.AdvertisementRegistrationMsg) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AdvertisementRegistrationMsg\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.AdvertisementRegistrationMsg)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AdvertisementRegistrationMsg : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.AdvertisementMsg AdvertisementMsg
  {
    get {
      if (_tag != Tag.AdvertisementMsg) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AdvertisementMsg\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.AdvertisementMsg)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AdvertisementMsg : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.Ping Ping
  {
    get {
      if (_tag != Tag.Ping) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"Ping\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.Ping)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.Ping : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SetVizOrigin SetVizOrigin
  {
    get {
      if (_tag != Tag.SetVizOrigin) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetVizOrigin\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SetVizOrigin)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetVizOrigin : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ImageChunk ImageChunk
  {
    get {
      if (_tag != Tag.ImageChunk) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ImageChunk\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ImageChunk)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ImageChunk : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.CameraCalibration CameraCalibration
  {
    get {
      if (_tag != Tag.CameraCalibration) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CameraCalibration\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.CameraCalibration)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CameraCalibration : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.IMURequest IMURequest
  {
    get {
      if (_tag != Tag.IMURequest) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"IMURequest\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.IMURequest)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.IMURequest : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.RobotInterface.IMUTemperature IMUTemperature
  {
    get {
      if (_tag != Tag.IMUTemperature) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"IMUTemperature\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.RobotInterface.IMUTemperature)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.IMUTemperature : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.StartControllerTestMode StartControllerTestMode
  {
    get {
      if (_tag != Tag.StartControllerTestMode) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"StartControllerTestMode\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.StartControllerTestMode)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.StartControllerTestMode : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.RawPWM RawPWM
  {
    get {
      if (_tag != Tag.RawPWM) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RawPWM\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.RawPWM)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RawPWM : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.SetConnectionStatus SetConnectionStatus
  {
    get {
      if (_tag != Tag.SetConnectionStatus) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetConnectionStatus\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.SetConnectionStatus)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetConnectionStatus : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.SendBLEConnectionStatus SendBLEConnectionStatus
  {
    get {
      if (_tag != Tag.SendBLEConnectionStatus) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SendBLEConnectionStatus\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.SendBLEConnectionStatus)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SendBLEConnectionStatus : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.SetBLEPin SetBLEPin
  {
    get {
      if (_tag != Tag.SetBLEPin) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetBLEPin\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.SetBLEPin)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetBLEPin : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.WifiScanResponse WifiScanResponse
  {
    get {
      if (_tag != Tag.WifiScanResponse) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"WifiScanResponse\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.WifiScanResponse)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.WifiScanResponse : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.WifiConnectResponse WifiConnectResponse
  {
    get {
      if (_tag != Tag.WifiConnectResponse) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"WifiConnectResponse\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.WifiConnectResponse)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.WifiConnectResponse : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.SwitchboardInterface.HasBleKeysResponse HasBleKeysResponse
  {
    get {
      if (_tag != Tag.HasBleKeysResponse) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"HasBleKeysResponse\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.SwitchboardInterface.HasBleKeysResponse)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.HasBleKeysResponse : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Util.AnkiLab.ActivateExperimentRequest ActivateExperimentRequest
  {
    get {
      if (_tag != Tag.ActivateExperimentRequest) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ActivateExperimentRequest\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Util.AnkiLab.ActivateExperimentRequest)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ActivateExperimentRequest : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Util.AnkiLab.ActivateExperimentResponse ActivateExperimentResponse
  {
    get {
      if (_tag != Tag.ActivateExperimentResponse) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ActivateExperimentResponse\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Util.AnkiLab.ActivateExperimentResponse)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ActivateExperimentResponse : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ConnectToUiDevice ConnectToUiDevice
  {
    get {
      if (_tag != Tag.ConnectToUiDevice) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ConnectToUiDevice\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ConnectToUiDevice)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ConnectToUiDevice : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DisconnectFromUiDevice DisconnectFromUiDevice
  {
    get {
      if (_tag != Tag.DisconnectFromUiDevice) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DisconnectFromUiDevice\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DisconnectFromUiDevice)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DisconnectFromUiDevice : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.UserLoggedIn UserLoggedIn
  {
    get {
      if (_tag != Tag.UserLoggedIn) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"UserLoggedIn\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.UserLoggedIn)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.UserLoggedIn : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DriveWheels DriveWheels
  {
    get {
      if (_tag != Tag.DriveWheels) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DriveWheels\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DriveWheels)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DriveWheels : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableLiftPower EnableLiftPower
  {
    get {
      if (_tag != Tag.EnableLiftPower) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableLiftPower\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableLiftPower)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableLiftPower : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableCliffSensor EnableCliffSensor
  {
    get {
      if (_tag != Tag.EnableCliffSensor) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableCliffSensor\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableCliffSensor)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableCliffSensor : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableStopOnCliff EnableStopOnCliff
  {
    get {
      if (_tag != Tag.EnableStopOnCliff) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableStopOnCliff\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableStopOnCliff)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableStopOnCliff : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.StopAllMotors StopAllMotors
  {
    get {
      if (_tag != Tag.StopAllMotors) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"StopAllMotors\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.StopAllMotors)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.StopAllMotors : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ControllerGains ControllerGains
  {
    get {
      if (_tag != Tag.ControllerGains) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ControllerGains\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ControllerGains)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ControllerGains : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RollActionParams RollActionParams
  {
    get {
      if (_tag != Tag.RollActionParams) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RollActionParams\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RollActionParams)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RollActionParams : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetMotionModelParams SetMotionModelParams
  {
    get {
      if (_tag != Tag.SetMotionModelParams) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetMotionModelParams\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetMotionModelParams)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetMotionModelParams : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetRobotVolume SetRobotVolume
  {
    get {
      if (_tag != Tag.SetRobotVolume) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetRobotVolume\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetRobotVolume)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetRobotVolume : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ForceDelocalizeRobot ForceDelocalizeRobot
  {
    get {
      if (_tag != Tag.ForceDelocalizeRobot) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ForceDelocalizeRobot\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ForceDelocalizeRobot)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ForceDelocalizeRobot : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CancelAction CancelAction
  {
    get {
      if (_tag != Tag.CancelAction) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CancelAction\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CancelAction)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CancelAction : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.CancelActionByIdTag CancelActionByIdTag
  {
    get {
      if (_tag != Tag.CancelActionByIdTag) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"CancelActionByIdTag\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.CancelActionByIdTag)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.CancelActionByIdTag : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.QueueSingleAction QueueSingleAction
  {
    get {
      if (_tag != Tag.QueueSingleAction) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"QueueSingleAction\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.QueueSingleAction)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.QueueSingleAction : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.QueueCompoundAction QueueCompoundAction
  {
    get {
      if (_tag != Tag.QueueCompoundAction) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"QueueCompoundAction\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.QueueCompoundAction)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.QueueCompoundAction : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RedirectViz RedirectViz
  {
    get {
      if (_tag != Tag.RedirectViz) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RedirectViz\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RedirectViz)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RedirectViz : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ImageRequest ImageRequest
  {
    get {
      if (_tag != Tag.ImageRequest) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ImageRequest\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ImageRequest)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ImageRequest : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SaveImages SaveImages
  {
    get {
      if (_tag != Tag.SaveImages) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SaveImages\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SaveImages)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SaveImages : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableColorImages EnableColorImages
  {
    get {
      if (_tag != Tag.EnableColorImages) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableColorImages\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableColorImages)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableColorImages : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SaveRobotState SaveRobotState
  {
    get {
      if (_tag != Tag.SaveRobotState) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SaveRobotState\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SaveRobotState)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SaveRobotState : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableDisplay EnableDisplay
  {
    get {
      if (_tag != Tag.EnableDisplay) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableDisplay\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableDisplay)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableDisplay : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ExecuteTestPlan ExecuteTestPlan
  {
    get {
      if (_tag != Tag.ExecuteTestPlan) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ExecuteTestPlan\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ExecuteTestPlan)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ExecuteTestPlan : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SelectNextObject SelectNextObject
  {
    get {
      if (_tag != Tag.SelectNextObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SelectNextObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SelectNextObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SelectNextObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetRobotCarryingObject SetRobotCarryingObject
  {
    get {
      if (_tag != Tag.SetRobotCarryingObject) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetRobotCarryingObject\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetRobotCarryingObject)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetRobotCarryingObject : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DeleteAllCustomObjects DeleteAllCustomObjects
  {
    get {
      if (_tag != Tag.DeleteAllCustomObjects) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DeleteAllCustomObjects\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DeleteAllCustomObjects)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DeleteAllCustomObjects : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisionWhileMoving VisionWhileMoving
  {
    get {
      if (_tag != Tag.VisionWhileMoving) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisionWhileMoving\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisionWhileMoving)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisionWhileMoving : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisionRunMode VisionRunMode
  {
    get {
      if (_tag != Tag.VisionRunMode) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisionRunMode\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisionRunMode)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisionRunMode : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SaveFaceAlbumToFile SaveFaceAlbumToFile
  {
    get {
      if (_tag != Tag.SaveFaceAlbumToFile) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SaveFaceAlbumToFile\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SaveFaceAlbumToFile)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SaveFaceAlbumToFile : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.LoadFaceAlbumFromFile LoadFaceAlbumFromFile
  {
    get {
      if (_tag != Tag.LoadFaceAlbumFromFile) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"LoadFaceAlbumFromFile\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.LoadFaceAlbumFromFile)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.LoadFaceAlbumFromFile : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetCameraCaptureFormat SetCameraCaptureFormat
  {
    get {
      if (_tag != Tag.SetCameraCaptureFormat) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetCameraCaptureFormat\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetCameraCaptureFormat)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetCameraCaptureFormat : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetMemoryMapRenderEnabled SetMemoryMapRenderEnabled
  {
    get {
      if (_tag != Tag.SetMemoryMapRenderEnabled) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetMemoryMapRenderEnabled\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetMemoryMapRenderEnabled)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetMemoryMapRenderEnabled : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.FakeTriggerWordDetected FakeTriggerWordDetected
  {
    get {
      if (_tag != Tag.FakeTriggerWordDetected) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"FakeTriggerWordDetected\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.FakeTriggerWordDetected)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.FakeTriggerWordDetected : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.FakeCloudIntent FakeCloudIntent
  {
    get {
      if (_tag != Tag.FakeCloudIntent) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"FakeCloudIntent\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.FakeCloudIntent)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.FakeCloudIntent : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.FakeUserIntent FakeUserIntent
  {
    get {
      if (_tag != Tag.FakeUserIntent) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"FakeUserIntent\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.FakeUserIntent)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.FakeUserIntent : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ExecuteBehaviorByID ExecuteBehaviorByID
  {
    get {
      if (_tag != Tag.ExecuteBehaviorByID) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ExecuteBehaviorByID\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ExecuteBehaviorByID)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ExecuteBehaviorByID : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetLiftLoadTestAsActivatable SetLiftLoadTestAsActivatable
  {
    get {
      if (_tag != Tag.SetLiftLoadTestAsActivatable) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetLiftLoadTestAsActivatable\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetLiftLoadTestAsActivatable)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetLiftLoadTestAsActivatable : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.AbortPath AbortPath
  {
    get {
      if (_tag != Tag.AbortPath) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AbortPath\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.AbortPath)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AbortPath : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.AbortAll AbortAll
  {
    get {
      if (_tag != Tag.AbortAll) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"AbortAll\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.AbortAll)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.AbortAll : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.StartTestMode StartTestMode
  {
    get {
      if (_tag != Tag.StartTestMode) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"StartTestMode\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.StartTestMode)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.StartTestMode : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DrawPoseMarker DrawPoseMarker
  {
    get {
      if (_tag != Tag.DrawPoseMarker) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DrawPoseMarker\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DrawPoseMarker)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DrawPoseMarker : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ErasePoseMarker ErasePoseMarker
  {
    get {
      if (_tag != Tag.ErasePoseMarker) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ErasePoseMarker\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ErasePoseMarker)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ErasePoseMarker : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.VisualizeQuad VisualizeQuad
  {
    get {
      if (_tag != Tag.VisualizeQuad) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"VisualizeQuad\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.VisualizeQuad)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.VisualizeQuad : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EraseQuad EraseQuad
  {
    get {
      if (_tag != Tag.EraseQuad) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EraseQuad\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EraseQuad)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EraseQuad : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ReadAnimationFile ReadAnimationFile
  {
    get {
      if (_tag != Tag.ReadAnimationFile) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ReadAnimationFile\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ReadAnimationFile)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ReadAnimationFile : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RequestAvailableAnimationGroups RequestAvailableAnimationGroups
  {
    get {
      if (_tag != Tag.RequestAvailableAnimationGroups) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RequestAvailableAnimationGroups\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RequestAvailableAnimationGroups)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RequestAvailableAnimationGroups : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PushDrivingAnimations PushDrivingAnimations
  {
    get {
      if (_tag != Tag.PushDrivingAnimations) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PushDrivingAnimations\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PushDrivingAnimations)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PushDrivingAnimations : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RemoveDrivingAnimations RemoveDrivingAnimations
  {
    get {
      if (_tag != Tag.RemoveDrivingAnimations) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RemoveDrivingAnimations\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RemoveDrivingAnimations)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RemoveDrivingAnimations : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DisplayProceduralFace DisplayProceduralFace
  {
    get {
      if (_tag != Tag.DisplayProceduralFace) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DisplayProceduralFace\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DisplayProceduralFace)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DisplayProceduralFace : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetFaceHue SetFaceHue
  {
    get {
      if (_tag != Tag.SetFaceHue) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetFaceHue\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetFaceHue)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetFaceHue : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DisplayFaceImageBinaryChunk DisplayFaceImageBinaryChunk
  {
    get {
      if (_tag != Tag.DisplayFaceImageBinaryChunk) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DisplayFaceImageBinaryChunk\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DisplayFaceImageBinaryChunk)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DisplayFaceImageBinaryChunk : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetActiveObjectLEDs SetActiveObjectLEDs
  {
    get {
      if (_tag != Tag.SetActiveObjectLEDs) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetActiveObjectLEDs\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetActiveObjectLEDs)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetActiveObjectLEDs : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetAllActiveObjectLEDs SetAllActiveObjectLEDs
  {
    get {
      if (_tag != Tag.SetAllActiveObjectLEDs) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetAllActiveObjectLEDs\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetAllActiveObjectLEDs)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetAllActiveObjectLEDs : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetBackpackLEDs SetBackpackLEDs
  {
    get {
      if (_tag != Tag.SetBackpackLEDs) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetBackpackLEDs\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetBackpackLEDs)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetBackpackLEDs : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.EnableLightStates EnableLightStates
  {
    get {
      if (_tag != Tag.EnableLightStates) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"EnableLightStates\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.EnableLightStates)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.EnableLightStates : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.PlayCubeAnim PlayCubeAnim
  {
    get {
      if (_tag != Tag.PlayCubeAnim) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"PlayCubeAnim\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.PlayCubeAnim)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.PlayCubeAnim : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.StopCubeAnim StopCubeAnim
  {
    get {
      if (_tag != Tag.StopCubeAnim) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"StopCubeAnim\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.StopCubeAnim)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.StopCubeAnim : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetOnboardingStage SetOnboardingStage
  {
    get {
      if (_tag != Tag.SetOnboardingStage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetOnboardingStage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetOnboardingStage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetOnboardingStage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.MoodMessage MoodMessage
  {
    get {
      if (_tag != Tag.MoodMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"MoodMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.MoodMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.MoodMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetDebugConsoleVarMessage SetDebugConsoleVarMessage
  {
    get {
      if (_tag != Tag.SetDebugConsoleVarMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetDebugConsoleVarMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetDebugConsoleVarMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetDebugConsoleVarMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetAnimDebugConsoleVarMessage SetAnimDebugConsoleVarMessage
  {
    get {
      if (_tag != Tag.SetAnimDebugConsoleVarMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetAnimDebugConsoleVarMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetAnimDebugConsoleVarMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetAnimDebugConsoleVarMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RunDebugConsoleFuncMessage RunDebugConsoleFuncMessage
  {
    get {
      if (_tag != Tag.RunDebugConsoleFuncMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RunDebugConsoleFuncMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RunDebugConsoleFuncMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RunDebugConsoleFuncMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RunAnimDebugConsoleFuncMessage RunAnimDebugConsoleFuncMessage
  {
    get {
      if (_tag != Tag.RunAnimDebugConsoleFuncMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RunAnimDebugConsoleFuncMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RunAnimDebugConsoleFuncMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RunAnimDebugConsoleFuncMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.GetDebugConsoleVarMessage GetDebugConsoleVarMessage
  {
    get {
      if (_tag != Tag.GetDebugConsoleVarMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GetDebugConsoleVarMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GetDebugConsoleVarMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GetDebugConsoleVarMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.GetAllDebugConsoleVarMessage GetAllDebugConsoleVarMessage
  {
    get {
      if (_tag != Tag.GetAllDebugConsoleVarMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GetAllDebugConsoleVarMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GetAllDebugConsoleVarMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GetAllDebugConsoleVarMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.GetJsonDasLogsMessage GetJsonDasLogsMessage
  {
    get {
      if (_tag != Tag.GetJsonDasLogsMessage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"GetJsonDasLogsMessage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.GetJsonDasLogsMessage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.GetJsonDasLogsMessage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetEnableSpeedChooser SetEnableSpeedChooser
  {
    get {
      if (_tag != Tag.SetEnableSpeedChooser) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetEnableSpeedChooser\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetEnableSpeedChooser)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetEnableSpeedChooser : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.LogRawCliffData LogRawCliffData
  {
    get {
      if (_tag != Tag.LogRawCliffData) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"LogRawCliffData\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.LogRawCliffData)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.LogRawCliffData : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.LogRawProxData LogRawProxData
  {
    get {
      if (_tag != Tag.LogRawProxData) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"LogRawProxData\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.LogRawProxData)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.LogRawProxData : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ConnectToCube ConnectToCube
  {
    get {
      if (_tag != Tag.ConnectToCube) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ConnectToCube\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ConnectToCube)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ConnectToCube : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.DisconnectFromCube DisconnectFromCube
  {
    get {
      if (_tag != Tag.DisconnectFromCube) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"DisconnectFromCube\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.DisconnectFromCube)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.DisconnectFromCube : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ForgetPreferredCube ForgetPreferredCube
  {
    get {
      if (_tag != Tag.ForgetPreferredCube) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ForgetPreferredCube\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ForgetPreferredCube)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ForgetPreferredCube : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetPreferredCube SetPreferredCube
  {
    get {
      if (_tag != Tag.SetPreferredCube) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetPreferredCube\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetPreferredCube)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetPreferredCube : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SendAvailableObjects SendAvailableObjects
  {
    get {
      if (_tag != Tag.SendAvailableObjects) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SendAvailableObjects\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SendAvailableObjects)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SendAvailableObjects : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SaveCalibrationImage SaveCalibrationImage
  {
    get {
      if (_tag != Tag.SaveCalibrationImage) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SaveCalibrationImage\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SaveCalibrationImage)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SaveCalibrationImage : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ClearCalibrationImages ClearCalibrationImages
  {
    get {
      if (_tag != Tag.ClearCalibrationImages) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ClearCalibrationImages\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ClearCalibrationImages)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ClearCalibrationImages : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.ComputeCameraCalibration ComputeCameraCalibration
  {
    get {
      if (_tag != Tag.ComputeCameraCalibration) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"ComputeCameraCalibration\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.ComputeCameraCalibration)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.ComputeCameraCalibration : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.TransferFile TransferFile
  {
    get {
      if (_tag != Tag.TransferFile) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"TransferFile\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.TransferFile)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.TransferFile : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.SetCameraSettings SetCameraSettings
  {
    get {
      if (_tag != Tag.SetCameraSettings) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"SetCameraSettings\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.SetCameraSettings)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.SetCameraSettings : Tag.INVALID;
      _state = value;
    }
  }

  public Anki.Vector.ExternalInterface.RequestRobotSettings RequestRobotSettings
  {
    get {
      if (_tag != Tag.RequestRobotSettings) {
        throw new System.InvalidOperationException(string.Format(
          "Cannot access union member \"RequestRobotSettings\" when a value of type {0} is stored.",
          _tag.ToString()));
      }
      return (Anki.Vector.ExternalInterface.RequestRobotSettings)this._state;
    }
    
    set {
      _tag = (value != null) ? Tag.RequestRobotSettings : Tag.INVALID;
      _state = value;
    }
  }

  public MessageGameToEngine Initialize<T>(T state)
  {
    _state = state;
    if(typeof(T) == typeof(Anki.Vector.ExternalInterface.UiDeviceConnectionWrongVersion))
    {
      _tag = Tag.UiDeviceConnectionWrongVersion;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.MoveHead))
    {
      _tag = Tag.MoveHead;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.MoveLift))
    {
      _tag = Tag.MoveLift;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DriveArc))
    {
      _tag = Tag.DriveArc;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RobotHistoryRequest))
    {
      _tag = Tag.RobotHistoryRequest;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DisplayFaceImageRGBChunk))
    {
      _tag = Tag.DisplayFaceImageRGBChunk;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.AppIntent))
    {
      _tag = Tag.AppIntent;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CancelFaceEnrollment))
    {
      _tag = Tag.CancelFaceEnrollment;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RequestEnrolledNames))
    {
      _tag = Tag.RequestEnrolledNames;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.UpdateEnrolledFaceByID))
    {
      _tag = Tag.UpdateEnrolledFaceByID;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EraseEnrolledFaceByID))
    {
      _tag = Tag.EraseEnrolledFaceByID;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EraseAllEnrolledFaces))
    {
      _tag = Tag.EraseAllEnrolledFaces;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetFaceToEnroll))
    {
      _tag = Tag.SetFaceToEnroll;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableVisionMode))
    {
      _tag = Tag.EnableVisionMode;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RequestAvailableAnimations))
    {
      _tag = Tag.RequestAvailableAnimations;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GotoPose))
    {
      _tag = Tag.GotoPose;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DriveStraight))
    {
      _tag = Tag.DriveStraight;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnInPlace))
    {
      _tag = Tag.TurnInPlace;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetHeadAngle))
    {
      _tag = Tag.SetHeadAngle;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetLiftHeight))
    {
      _tag = Tag.SetLiftHeight;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.AlignWithObject))
    {
      _tag = Tag.AlignWithObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetLiftAngle))
    {
      _tag = Tag.SetLiftAngle;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DeleteCustomMarkerObjects))
    {
      _tag = Tag.DeleteCustomMarkerObjects;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DeleteFixedCustomObjects))
    {
      _tag = Tag.DeleteFixedCustomObjects;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.UndefineAllCustomMarkerObjects))
    {
      _tag = Tag.UndefineAllCustomMarkerObjects;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CreateFixedCustomObject))
    {
      _tag = Tag.CreateFixedCustomObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DefineCustomBox))
    {
      _tag = Tag.DefineCustomBox;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DefineCustomCube))
    {
      _tag = Tag.DefineCustomCube;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DefineCustomWall))
    {
      _tag = Tag.DefineCustomWall;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetMemoryMapBroadcastFrequency_sec))
    {
      _tag = Tag.SetMemoryMapBroadcastFrequency_sec;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.PostAudioEvent))
    {
      _tag = Tag.PostAudioEvent;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.StopAllAudioEvents))
    {
      _tag = Tag.StopAllAudioEvents;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.PostAudioGameState))
    {
      _tag = Tag.PostAudioGameState;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.PostAudioSwitchState))
    {
      _tag = Tag.PostAudioSwitchState;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.PostAudioParameter))
    {
      _tag = Tag.PostAudioParameter;
    }
    else if(typeof(T) == typeof(Anki.AudioEngine.Multiplexer.PostAudioMusicState))
    {
      _tag = Tag.PostAudioMusicState;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CalibrateMotors))
    {
      _tag = Tag.CalibrateMotors;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CliffAlignToWhite))
    {
      _tag = Tag.CliffAlignToWhite;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.FlipBlock))
    {
      _tag = Tag.FlipBlock;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GotoObject))
    {
      _tag = Tag.GotoObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.MountCharger))
    {
      _tag = Tag.MountCharger;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PanAndTilt))
    {
      _tag = Tag.PanAndTilt;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PickupObject))
    {
      _tag = Tag.PickupObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlaceObjectOnGround))
    {
      _tag = Tag.PlaceObjectOnGround;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlaceObjectOnGroundHere))
    {
      _tag = Tag.PlaceObjectOnGroundHere;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlaceOnObject))
    {
      _tag = Tag.PlaceOnObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlaceRelObject))
    {
      _tag = Tag.PlaceRelObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlayAnimation))
    {
      _tag = Tag.PlayAnimation;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ListAnimations))
    {
      _tag = Tag.ListAnimations;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlayAnimationGroup))
    {
      _tag = Tag.PlayAnimationGroup;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlayAnimationTrigger))
    {
      _tag = Tag.PlayAnimationTrigger;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PopAWheelie))
    {
      _tag = Tag.PopAWheelie;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.FacePlant))
    {
      _tag = Tag.FacePlant;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RealignWithObject))
    {
      _tag = Tag.RealignWithObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RollObject))
    {
      _tag = Tag.RollObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SayText))
    {
      _tag = Tag.SayText;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SearchForNearbyObject))
    {
      _tag = Tag.SearchForNearbyObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TrackToFace))
    {
      _tag = Tag.TrackToFace;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TrackToObject))
    {
      _tag = Tag.TrackToObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TrackToLaserPoint))
    {
      _tag = Tag.TrackToLaserPoint;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TrackToPet))
    {
      _tag = Tag.TrackToPet;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnInPlaceAtSpeed))
    {
      _tag = Tag.TurnInPlaceAtSpeed;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnTowardsFace))
    {
      _tag = Tag.TurnTowardsFace;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnTowardsImagePoint))
    {
      _tag = Tag.TurnTowardsImagePoint;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnTowardsLastFacePose))
    {
      _tag = Tag.TurnTowardsLastFacePose;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnTowardsObject))
    {
      _tag = Tag.TurnTowardsObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TurnTowardsPose))
    {
      _tag = Tag.TurnTowardsPose;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisuallyVerifyFace))
    {
      _tag = Tag.VisuallyVerifyFace;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisuallyVerifyObject))
    {
      _tag = Tag.VisuallyVerifyObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisuallyVerifyNoObjectAtPose))
    {
      _tag = Tag.VisuallyVerifyNoObjectAtPose;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.Wait))
    {
      _tag = Tag.Wait;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.WaitForImages))
    {
      _tag = Tag.WaitForImages;
    }
    else if(typeof(T) == typeof(Anki.Vector.AdvertisementRegistrationMsg))
    {
      _tag = Tag.AdvertisementRegistrationMsg;
    }
    else if(typeof(T) == typeof(Anki.Vector.AdvertisementMsg))
    {
      _tag = Tag.AdvertisementMsg;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.Ping))
    {
      _tag = Tag.Ping;
    }
    else if(typeof(T) == typeof(Anki.Vector.SetVizOrigin))
    {
      _tag = Tag.SetVizOrigin;
    }
    else if(typeof(T) == typeof(Anki.Vector.ImageChunk))
    {
      _tag = Tag.ImageChunk;
    }
    else if(typeof(T) == typeof(Anki.Vector.CameraCalibration))
    {
      _tag = Tag.CameraCalibration;
    }
    else if(typeof(T) == typeof(Anki.Vector.IMURequest))
    {
      _tag = Tag.IMURequest;
    }
    else if(typeof(T) == typeof(Anki.Vector.RobotInterface.IMUTemperature))
    {
      _tag = Tag.IMUTemperature;
    }
    else if(typeof(T) == typeof(Anki.Vector.StartControllerTestMode))
    {
      _tag = Tag.StartControllerTestMode;
    }
    else if(typeof(T) == typeof(Anki.Vector.RawPWM))
    {
      _tag = Tag.RawPWM;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.SetConnectionStatus))
    {
      _tag = Tag.SetConnectionStatus;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.SendBLEConnectionStatus))
    {
      _tag = Tag.SendBLEConnectionStatus;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.SetBLEPin))
    {
      _tag = Tag.SetBLEPin;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.WifiScanResponse))
    {
      _tag = Tag.WifiScanResponse;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.WifiConnectResponse))
    {
      _tag = Tag.WifiConnectResponse;
    }
    else if(typeof(T) == typeof(Anki.Vector.SwitchboardInterface.HasBleKeysResponse))
    {
      _tag = Tag.HasBleKeysResponse;
    }
    else if(typeof(T) == typeof(Anki.Util.AnkiLab.ActivateExperimentRequest))
    {
      _tag = Tag.ActivateExperimentRequest;
    }
    else if(typeof(T) == typeof(Anki.Util.AnkiLab.ActivateExperimentResponse))
    {
      _tag = Tag.ActivateExperimentResponse;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ConnectToUiDevice))
    {
      _tag = Tag.ConnectToUiDevice;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DisconnectFromUiDevice))
    {
      _tag = Tag.DisconnectFromUiDevice;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.UserLoggedIn))
    {
      _tag = Tag.UserLoggedIn;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DriveWheels))
    {
      _tag = Tag.DriveWheels;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableLiftPower))
    {
      _tag = Tag.EnableLiftPower;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableCliffSensor))
    {
      _tag = Tag.EnableCliffSensor;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableStopOnCliff))
    {
      _tag = Tag.EnableStopOnCliff;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.StopAllMotors))
    {
      _tag = Tag.StopAllMotors;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ControllerGains))
    {
      _tag = Tag.ControllerGains;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RollActionParams))
    {
      _tag = Tag.RollActionParams;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetMotionModelParams))
    {
      _tag = Tag.SetMotionModelParams;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetRobotVolume))
    {
      _tag = Tag.SetRobotVolume;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ForceDelocalizeRobot))
    {
      _tag = Tag.ForceDelocalizeRobot;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CancelAction))
    {
      _tag = Tag.CancelAction;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.CancelActionByIdTag))
    {
      _tag = Tag.CancelActionByIdTag;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.QueueSingleAction))
    {
      _tag = Tag.QueueSingleAction;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.QueueCompoundAction))
    {
      _tag = Tag.QueueCompoundAction;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RedirectViz))
    {
      _tag = Tag.RedirectViz;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ImageRequest))
    {
      _tag = Tag.ImageRequest;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SaveImages))
    {
      _tag = Tag.SaveImages;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableColorImages))
    {
      _tag = Tag.EnableColorImages;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SaveRobotState))
    {
      _tag = Tag.SaveRobotState;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableDisplay))
    {
      _tag = Tag.EnableDisplay;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ExecuteTestPlan))
    {
      _tag = Tag.ExecuteTestPlan;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SelectNextObject))
    {
      _tag = Tag.SelectNextObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetRobotCarryingObject))
    {
      _tag = Tag.SetRobotCarryingObject;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DeleteAllCustomObjects))
    {
      _tag = Tag.DeleteAllCustomObjects;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisionWhileMoving))
    {
      _tag = Tag.VisionWhileMoving;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisionRunMode))
    {
      _tag = Tag.VisionRunMode;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SaveFaceAlbumToFile))
    {
      _tag = Tag.SaveFaceAlbumToFile;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.LoadFaceAlbumFromFile))
    {
      _tag = Tag.LoadFaceAlbumFromFile;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetCameraCaptureFormat))
    {
      _tag = Tag.SetCameraCaptureFormat;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetMemoryMapRenderEnabled))
    {
      _tag = Tag.SetMemoryMapRenderEnabled;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.FakeTriggerWordDetected))
    {
      _tag = Tag.FakeTriggerWordDetected;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.FakeCloudIntent))
    {
      _tag = Tag.FakeCloudIntent;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.FakeUserIntent))
    {
      _tag = Tag.FakeUserIntent;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ExecuteBehaviorByID))
    {
      _tag = Tag.ExecuteBehaviorByID;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetLiftLoadTestAsActivatable))
    {
      _tag = Tag.SetLiftLoadTestAsActivatable;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.AbortPath))
    {
      _tag = Tag.AbortPath;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.AbortAll))
    {
      _tag = Tag.AbortAll;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.StartTestMode))
    {
      _tag = Tag.StartTestMode;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DrawPoseMarker))
    {
      _tag = Tag.DrawPoseMarker;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ErasePoseMarker))
    {
      _tag = Tag.ErasePoseMarker;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.VisualizeQuad))
    {
      _tag = Tag.VisualizeQuad;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EraseQuad))
    {
      _tag = Tag.EraseQuad;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ReadAnimationFile))
    {
      _tag = Tag.ReadAnimationFile;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RequestAvailableAnimationGroups))
    {
      _tag = Tag.RequestAvailableAnimationGroups;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PushDrivingAnimations))
    {
      _tag = Tag.PushDrivingAnimations;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RemoveDrivingAnimations))
    {
      _tag = Tag.RemoveDrivingAnimations;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DisplayProceduralFace))
    {
      _tag = Tag.DisplayProceduralFace;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetFaceHue))
    {
      _tag = Tag.SetFaceHue;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DisplayFaceImageBinaryChunk))
    {
      _tag = Tag.DisplayFaceImageBinaryChunk;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetActiveObjectLEDs))
    {
      _tag = Tag.SetActiveObjectLEDs;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetAllActiveObjectLEDs))
    {
      _tag = Tag.SetAllActiveObjectLEDs;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetBackpackLEDs))
    {
      _tag = Tag.SetBackpackLEDs;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.EnableLightStates))
    {
      _tag = Tag.EnableLightStates;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.PlayCubeAnim))
    {
      _tag = Tag.PlayCubeAnim;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.StopCubeAnim))
    {
      _tag = Tag.StopCubeAnim;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetOnboardingStage))
    {
      _tag = Tag.SetOnboardingStage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.MoodMessage))
    {
      _tag = Tag.MoodMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetDebugConsoleVarMessage))
    {
      _tag = Tag.SetDebugConsoleVarMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetAnimDebugConsoleVarMessage))
    {
      _tag = Tag.SetAnimDebugConsoleVarMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RunDebugConsoleFuncMessage))
    {
      _tag = Tag.RunDebugConsoleFuncMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RunAnimDebugConsoleFuncMessage))
    {
      _tag = Tag.RunAnimDebugConsoleFuncMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GetDebugConsoleVarMessage))
    {
      _tag = Tag.GetDebugConsoleVarMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GetAllDebugConsoleVarMessage))
    {
      _tag = Tag.GetAllDebugConsoleVarMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.GetJsonDasLogsMessage))
    {
      _tag = Tag.GetJsonDasLogsMessage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetEnableSpeedChooser))
    {
      _tag = Tag.SetEnableSpeedChooser;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.LogRawCliffData))
    {
      _tag = Tag.LogRawCliffData;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.LogRawProxData))
    {
      _tag = Tag.LogRawProxData;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ConnectToCube))
    {
      _tag = Tag.ConnectToCube;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.DisconnectFromCube))
    {
      _tag = Tag.DisconnectFromCube;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ForgetPreferredCube))
    {
      _tag = Tag.ForgetPreferredCube;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetPreferredCube))
    {
      _tag = Tag.SetPreferredCube;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SendAvailableObjects))
    {
      _tag = Tag.SendAvailableObjects;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SaveCalibrationImage))
    {
      _tag = Tag.SaveCalibrationImage;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ClearCalibrationImages))
    {
      _tag = Tag.ClearCalibrationImages;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.ComputeCameraCalibration))
    {
      _tag = Tag.ComputeCameraCalibration;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.TransferFile))
    {
      _tag = Tag.TransferFile;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.SetCameraSettings))
    {
      _tag = Tag.SetCameraSettings;
    }
    else if(typeof(T) == typeof(Anki.Vector.ExternalInterface.RequestRobotSettings))
    {
      _tag = Tag.RequestRobotSettings;
    }
    else
    {
      _state = null;
      _tag = Tag.INVALID;
    }

    return this;
  }

  /**** Constructors ****/

  public MessageGameToEngine()
  {
  }

  public MessageGameToEngine(System.IO.Stream stream)
  {
    Unpack(stream);
  }

  public MessageGameToEngine(System.IO.BinaryReader reader)
  {
    Unpack(reader);
  }

  public void Unpack(System.IO.Stream stream)
  {
    System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
    Unpack(reader);
  }

  public void Unpack(System.IO.BinaryReader reader)
  {
    Tag newTag = (Tag)reader.ReadByte();
    switch(newTag) {
    case Tag.UiDeviceConnectionWrongVersion:
      UiDeviceConnectionWrongVersion = new Anki.Vector.ExternalInterface.UiDeviceConnectionWrongVersion(reader);
      break;
    case Tag.MoveHead:
      MoveHead = new Anki.Vector.ExternalInterface.MoveHead(reader);
      break;
    case Tag.MoveLift:
      MoveLift = new Anki.Vector.ExternalInterface.MoveLift(reader);
      break;
    case Tag.DriveArc:
      DriveArc = new Anki.Vector.ExternalInterface.DriveArc(reader);
      break;
    case Tag.RobotHistoryRequest:
      RobotHistoryRequest = new Anki.Vector.ExternalInterface.RobotHistoryRequest(reader);
      break;
    case Tag.DisplayFaceImageRGBChunk:
      DisplayFaceImageRGBChunk = new Anki.Vector.ExternalInterface.DisplayFaceImageRGBChunk(reader);
      break;
    case Tag.AppIntent:
      AppIntent = new Anki.Vector.ExternalInterface.AppIntent(reader);
      break;
    case Tag.CancelFaceEnrollment:
      CancelFaceEnrollment = new Anki.Vector.ExternalInterface.CancelFaceEnrollment(reader);
      break;
    case Tag.RequestEnrolledNames:
      RequestEnrolledNames = new Anki.Vector.ExternalInterface.RequestEnrolledNames(reader);
      break;
    case Tag.UpdateEnrolledFaceByID:
      UpdateEnrolledFaceByID = new Anki.Vector.ExternalInterface.UpdateEnrolledFaceByID(reader);
      break;
    case Tag.EraseEnrolledFaceByID:
      EraseEnrolledFaceByID = new Anki.Vector.ExternalInterface.EraseEnrolledFaceByID(reader);
      break;
    case Tag.EraseAllEnrolledFaces:
      EraseAllEnrolledFaces = new Anki.Vector.ExternalInterface.EraseAllEnrolledFaces(reader);
      break;
    case Tag.SetFaceToEnroll:
      SetFaceToEnroll = new Anki.Vector.ExternalInterface.SetFaceToEnroll(reader);
      break;
    case Tag.EnableVisionMode:
      EnableVisionMode = new Anki.Vector.ExternalInterface.EnableVisionMode(reader);
      break;
    case Tag.RequestAvailableAnimations:
      RequestAvailableAnimations = new Anki.Vector.ExternalInterface.RequestAvailableAnimations(reader);
      break;
    case Tag.GotoPose:
      GotoPose = new Anki.Vector.ExternalInterface.GotoPose(reader);
      break;
    case Tag.DriveStraight:
      DriveStraight = new Anki.Vector.ExternalInterface.DriveStraight(reader);
      break;
    case Tag.TurnInPlace:
      TurnInPlace = new Anki.Vector.ExternalInterface.TurnInPlace(reader);
      break;
    case Tag.SetHeadAngle:
      SetHeadAngle = new Anki.Vector.ExternalInterface.SetHeadAngle(reader);
      break;
    case Tag.SetLiftHeight:
      SetLiftHeight = new Anki.Vector.ExternalInterface.SetLiftHeight(reader);
      break;
    case Tag.AlignWithObject:
      AlignWithObject = new Anki.Vector.ExternalInterface.AlignWithObject(reader);
      break;
    case Tag.SetLiftAngle:
      SetLiftAngle = new Anki.Vector.ExternalInterface.SetLiftAngle(reader);
      break;
    case Tag.DeleteCustomMarkerObjects:
      DeleteCustomMarkerObjects = new Anki.Vector.ExternalInterface.DeleteCustomMarkerObjects(reader);
      break;
    case Tag.DeleteFixedCustomObjects:
      DeleteFixedCustomObjects = new Anki.Vector.ExternalInterface.DeleteFixedCustomObjects(reader);
      break;
    case Tag.UndefineAllCustomMarkerObjects:
      UndefineAllCustomMarkerObjects = new Anki.Vector.ExternalInterface.UndefineAllCustomMarkerObjects(reader);
      break;
    case Tag.CreateFixedCustomObject:
      CreateFixedCustomObject = new Anki.Vector.ExternalInterface.CreateFixedCustomObject(reader);
      break;
    case Tag.DefineCustomBox:
      DefineCustomBox = new Anki.Vector.ExternalInterface.DefineCustomBox(reader);
      break;
    case Tag.DefineCustomCube:
      DefineCustomCube = new Anki.Vector.ExternalInterface.DefineCustomCube(reader);
      break;
    case Tag.DefineCustomWall:
      DefineCustomWall = new Anki.Vector.ExternalInterface.DefineCustomWall(reader);
      break;
    case Tag.SetMemoryMapBroadcastFrequency_sec:
      SetMemoryMapBroadcastFrequency_sec = new Anki.Vector.ExternalInterface.SetMemoryMapBroadcastFrequency_sec(reader);
      break;
    case Tag.PostAudioEvent:
      PostAudioEvent = new Anki.AudioEngine.Multiplexer.PostAudioEvent(reader);
      break;
    case Tag.StopAllAudioEvents:
      StopAllAudioEvents = new Anki.AudioEngine.Multiplexer.StopAllAudioEvents(reader);
      break;
    case Tag.PostAudioGameState:
      PostAudioGameState = new Anki.AudioEngine.Multiplexer.PostAudioGameState(reader);
      break;
    case Tag.PostAudioSwitchState:
      PostAudioSwitchState = new Anki.AudioEngine.Multiplexer.PostAudioSwitchState(reader);
      break;
    case Tag.PostAudioParameter:
      PostAudioParameter = new Anki.AudioEngine.Multiplexer.PostAudioParameter(reader);
      break;
    case Tag.PostAudioMusicState:
      PostAudioMusicState = new Anki.AudioEngine.Multiplexer.PostAudioMusicState(reader);
      break;
    case Tag.CalibrateMotors:
      CalibrateMotors = new Anki.Vector.ExternalInterface.CalibrateMotors(reader);
      break;
    case Tag.CliffAlignToWhite:
      CliffAlignToWhite = new Anki.Vector.ExternalInterface.CliffAlignToWhite(reader);
      break;
    case Tag.FlipBlock:
      FlipBlock = new Anki.Vector.ExternalInterface.FlipBlock(reader);
      break;
    case Tag.GotoObject:
      GotoObject = new Anki.Vector.ExternalInterface.GotoObject(reader);
      break;
    case Tag.MountCharger:
      MountCharger = new Anki.Vector.ExternalInterface.MountCharger(reader);
      break;
    case Tag.PanAndTilt:
      PanAndTilt = new Anki.Vector.ExternalInterface.PanAndTilt(reader);
      break;
    case Tag.PickupObject:
      PickupObject = new Anki.Vector.ExternalInterface.PickupObject(reader);
      break;
    case Tag.PlaceObjectOnGround:
      PlaceObjectOnGround = new Anki.Vector.ExternalInterface.PlaceObjectOnGround(reader);
      break;
    case Tag.PlaceObjectOnGroundHere:
      PlaceObjectOnGroundHere = new Anki.Vector.ExternalInterface.PlaceObjectOnGroundHere(reader);
      break;
    case Tag.PlaceOnObject:
      PlaceOnObject = new Anki.Vector.ExternalInterface.PlaceOnObject(reader);
      break;
    case Tag.PlaceRelObject:
      PlaceRelObject = new Anki.Vector.ExternalInterface.PlaceRelObject(reader);
      break;
    case Tag.PlayAnimation:
      PlayAnimation = new Anki.Vector.ExternalInterface.PlayAnimation(reader);
      break;
    case Tag.ListAnimations:
      ListAnimations = new Anki.Vector.ExternalInterface.ListAnimations(reader);
      break;
    case Tag.PlayAnimationGroup:
      PlayAnimationGroup = new Anki.Vector.ExternalInterface.PlayAnimationGroup(reader);
      break;
    case Tag.PlayAnimationTrigger:
      PlayAnimationTrigger = new Anki.Vector.ExternalInterface.PlayAnimationTrigger(reader);
      break;
    case Tag.PopAWheelie:
      PopAWheelie = new Anki.Vector.ExternalInterface.PopAWheelie(reader);
      break;
    case Tag.FacePlant:
      FacePlant = new Anki.Vector.ExternalInterface.FacePlant(reader);
      break;
    case Tag.RealignWithObject:
      RealignWithObject = new Anki.Vector.ExternalInterface.RealignWithObject(reader);
      break;
    case Tag.RollObject:
      RollObject = new Anki.Vector.ExternalInterface.RollObject(reader);
      break;
    case Tag.SayText:
      SayText = new Anki.Vector.ExternalInterface.SayText(reader);
      break;
    case Tag.SearchForNearbyObject:
      SearchForNearbyObject = new Anki.Vector.ExternalInterface.SearchForNearbyObject(reader);
      break;
    case Tag.TrackToFace:
      TrackToFace = new Anki.Vector.ExternalInterface.TrackToFace(reader);
      break;
    case Tag.TrackToObject:
      TrackToObject = new Anki.Vector.ExternalInterface.TrackToObject(reader);
      break;
    case Tag.TrackToLaserPoint:
      TrackToLaserPoint = new Anki.Vector.ExternalInterface.TrackToLaserPoint(reader);
      break;
    case Tag.TrackToPet:
      TrackToPet = new Anki.Vector.ExternalInterface.TrackToPet(reader);
      break;
    case Tag.TurnInPlaceAtSpeed:
      TurnInPlaceAtSpeed = new Anki.Vector.ExternalInterface.TurnInPlaceAtSpeed(reader);
      break;
    case Tag.TurnTowardsFace:
      TurnTowardsFace = new Anki.Vector.ExternalInterface.TurnTowardsFace(reader);
      break;
    case Tag.TurnTowardsImagePoint:
      TurnTowardsImagePoint = new Anki.Vector.ExternalInterface.TurnTowardsImagePoint(reader);
      break;
    case Tag.TurnTowardsLastFacePose:
      TurnTowardsLastFacePose = new Anki.Vector.ExternalInterface.TurnTowardsLastFacePose(reader);
      break;
    case Tag.TurnTowardsObject:
      TurnTowardsObject = new Anki.Vector.ExternalInterface.TurnTowardsObject(reader);
      break;
    case Tag.TurnTowardsPose:
      TurnTowardsPose = new Anki.Vector.ExternalInterface.TurnTowardsPose(reader);
      break;
    case Tag.VisuallyVerifyFace:
      VisuallyVerifyFace = new Anki.Vector.ExternalInterface.VisuallyVerifyFace(reader);
      break;
    case Tag.VisuallyVerifyObject:
      VisuallyVerifyObject = new Anki.Vector.ExternalInterface.VisuallyVerifyObject(reader);
      break;
    case Tag.VisuallyVerifyNoObjectAtPose:
      VisuallyVerifyNoObjectAtPose = new Anki.Vector.ExternalInterface.VisuallyVerifyNoObjectAtPose(reader);
      break;
    case Tag.Wait:
      Wait = new Anki.Vector.ExternalInterface.Wait(reader);
      break;
    case Tag.WaitForImages:
      WaitForImages = new Anki.Vector.ExternalInterface.WaitForImages(reader);
      break;
    case Tag.AdvertisementRegistrationMsg:
      AdvertisementRegistrationMsg = new Anki.Vector.AdvertisementRegistrationMsg(reader);
      break;
    case Tag.AdvertisementMsg:
      AdvertisementMsg = new Anki.Vector.AdvertisementMsg(reader);
      break;
    case Tag.Ping:
      Ping = new Anki.Vector.ExternalInterface.Ping(reader);
      break;
    case Tag.SetVizOrigin:
      SetVizOrigin = new Anki.Vector.SetVizOrigin(reader);
      break;
    case Tag.ImageChunk:
      ImageChunk = new Anki.Vector.ImageChunk(reader);
      break;
    case Tag.CameraCalibration:
      CameraCalibration = new Anki.Vector.CameraCalibration(reader);
      break;
    case Tag.IMURequest:
      IMURequest = new Anki.Vector.IMURequest(reader);
      break;
    case Tag.IMUTemperature:
      IMUTemperature = new Anki.Vector.RobotInterface.IMUTemperature(reader);
      break;
    case Tag.StartControllerTestMode:
      StartControllerTestMode = new Anki.Vector.StartControllerTestMode(reader);
      break;
    case Tag.RawPWM:
      RawPWM = new Anki.Vector.RawPWM(reader);
      break;
    case Tag.SetConnectionStatus:
      SetConnectionStatus = new Anki.Vector.SwitchboardInterface.SetConnectionStatus(reader);
      break;
    case Tag.SendBLEConnectionStatus:
      SendBLEConnectionStatus = new Anki.Vector.SwitchboardInterface.SendBLEConnectionStatus(reader);
      break;
    case Tag.SetBLEPin:
      SetBLEPin = new Anki.Vector.SwitchboardInterface.SetBLEPin(reader);
      break;
    case Tag.WifiScanResponse:
      WifiScanResponse = new Anki.Vector.SwitchboardInterface.WifiScanResponse(reader);
      break;
    case Tag.WifiConnectResponse:
      WifiConnectResponse = new Anki.Vector.SwitchboardInterface.WifiConnectResponse(reader);
      break;
    case Tag.HasBleKeysResponse:
      HasBleKeysResponse = new Anki.Vector.SwitchboardInterface.HasBleKeysResponse(reader);
      break;
    case Tag.ActivateExperimentRequest:
      ActivateExperimentRequest = new Anki.Util.AnkiLab.ActivateExperimentRequest(reader);
      break;
    case Tag.ActivateExperimentResponse:
      ActivateExperimentResponse = new Anki.Util.AnkiLab.ActivateExperimentResponse(reader);
      break;
    case Tag.ConnectToUiDevice:
      ConnectToUiDevice = new Anki.Vector.ExternalInterface.ConnectToUiDevice(reader);
      break;
    case Tag.DisconnectFromUiDevice:
      DisconnectFromUiDevice = new Anki.Vector.ExternalInterface.DisconnectFromUiDevice(reader);
      break;
    case Tag.UserLoggedIn:
      UserLoggedIn = new Anki.Vector.ExternalInterface.UserLoggedIn(reader);
      break;
    case Tag.DriveWheels:
      DriveWheels = new Anki.Vector.ExternalInterface.DriveWheels(reader);
      break;
    case Tag.EnableLiftPower:
      EnableLiftPower = new Anki.Vector.ExternalInterface.EnableLiftPower(reader);
      break;
    case Tag.EnableCliffSensor:
      EnableCliffSensor = new Anki.Vector.ExternalInterface.EnableCliffSensor(reader);
      break;
    case Tag.EnableStopOnCliff:
      EnableStopOnCliff = new Anki.Vector.ExternalInterface.EnableStopOnCliff(reader);
      break;
    case Tag.StopAllMotors:
      StopAllMotors = new Anki.Vector.ExternalInterface.StopAllMotors(reader);
      break;
    case Tag.ControllerGains:
      ControllerGains = new Anki.Vector.ExternalInterface.ControllerGains(reader);
      break;
    case Tag.RollActionParams:
      RollActionParams = new Anki.Vector.ExternalInterface.RollActionParams(reader);
      break;
    case Tag.SetMotionModelParams:
      SetMotionModelParams = new Anki.Vector.ExternalInterface.SetMotionModelParams(reader);
      break;
    case Tag.SetRobotVolume:
      SetRobotVolume = new Anki.Vector.ExternalInterface.SetRobotVolume(reader);
      break;
    case Tag.ForceDelocalizeRobot:
      ForceDelocalizeRobot = new Anki.Vector.ExternalInterface.ForceDelocalizeRobot(reader);
      break;
    case Tag.CancelAction:
      CancelAction = new Anki.Vector.ExternalInterface.CancelAction(reader);
      break;
    case Tag.CancelActionByIdTag:
      CancelActionByIdTag = new Anki.Vector.ExternalInterface.CancelActionByIdTag(reader);
      break;
    case Tag.QueueSingleAction:
      QueueSingleAction = new Anki.Vector.ExternalInterface.QueueSingleAction(reader);
      break;
    case Tag.QueueCompoundAction:
      QueueCompoundAction = new Anki.Vector.ExternalInterface.QueueCompoundAction(reader);
      break;
    case Tag.RedirectViz:
      RedirectViz = new Anki.Vector.ExternalInterface.RedirectViz(reader);
      break;
    case Tag.ImageRequest:
      ImageRequest = new Anki.Vector.ExternalInterface.ImageRequest(reader);
      break;
    case Tag.SaveImages:
      SaveImages = new Anki.Vector.ExternalInterface.SaveImages(reader);
      break;
    case Tag.EnableColorImages:
      EnableColorImages = new Anki.Vector.ExternalInterface.EnableColorImages(reader);
      break;
    case Tag.SaveRobotState:
      SaveRobotState = new Anki.Vector.ExternalInterface.SaveRobotState(reader);
      break;
    case Tag.EnableDisplay:
      EnableDisplay = new Anki.Vector.ExternalInterface.EnableDisplay(reader);
      break;
    case Tag.ExecuteTestPlan:
      ExecuteTestPlan = new Anki.Vector.ExternalInterface.ExecuteTestPlan(reader);
      break;
    case Tag.SelectNextObject:
      SelectNextObject = new Anki.Vector.ExternalInterface.SelectNextObject(reader);
      break;
    case Tag.SetRobotCarryingObject:
      SetRobotCarryingObject = new Anki.Vector.ExternalInterface.SetRobotCarryingObject(reader);
      break;
    case Tag.DeleteAllCustomObjects:
      DeleteAllCustomObjects = new Anki.Vector.ExternalInterface.DeleteAllCustomObjects(reader);
      break;
    case Tag.VisionWhileMoving:
      VisionWhileMoving = new Anki.Vector.ExternalInterface.VisionWhileMoving(reader);
      break;
    case Tag.VisionRunMode:
      VisionRunMode = new Anki.Vector.ExternalInterface.VisionRunMode(reader);
      break;
    case Tag.SaveFaceAlbumToFile:
      SaveFaceAlbumToFile = new Anki.Vector.ExternalInterface.SaveFaceAlbumToFile(reader);
      break;
    case Tag.LoadFaceAlbumFromFile:
      LoadFaceAlbumFromFile = new Anki.Vector.ExternalInterface.LoadFaceAlbumFromFile(reader);
      break;
    case Tag.SetCameraCaptureFormat:
      SetCameraCaptureFormat = new Anki.Vector.ExternalInterface.SetCameraCaptureFormat(reader);
      break;
    case Tag.SetMemoryMapRenderEnabled:
      SetMemoryMapRenderEnabled = new Anki.Vector.ExternalInterface.SetMemoryMapRenderEnabled(reader);
      break;
    case Tag.FakeTriggerWordDetected:
      FakeTriggerWordDetected = new Anki.Vector.ExternalInterface.FakeTriggerWordDetected(reader);
      break;
    case Tag.FakeCloudIntent:
      FakeCloudIntent = new Anki.Vector.ExternalInterface.FakeCloudIntent(reader);
      break;
    case Tag.FakeUserIntent:
      FakeUserIntent = new Anki.Vector.ExternalInterface.FakeUserIntent(reader);
      break;
    case Tag.ExecuteBehaviorByID:
      ExecuteBehaviorByID = new Anki.Vector.ExternalInterface.ExecuteBehaviorByID(reader);
      break;
    case Tag.SetLiftLoadTestAsActivatable:
      SetLiftLoadTestAsActivatable = new Anki.Vector.ExternalInterface.SetLiftLoadTestAsActivatable(reader);
      break;
    case Tag.AbortPath:
      AbortPath = new Anki.Vector.ExternalInterface.AbortPath(reader);
      break;
    case Tag.AbortAll:
      AbortAll = new Anki.Vector.ExternalInterface.AbortAll(reader);
      break;
    case Tag.StartTestMode:
      StartTestMode = new Anki.Vector.ExternalInterface.StartTestMode(reader);
      break;
    case Tag.DrawPoseMarker:
      DrawPoseMarker = new Anki.Vector.ExternalInterface.DrawPoseMarker(reader);
      break;
    case Tag.ErasePoseMarker:
      ErasePoseMarker = new Anki.Vector.ExternalInterface.ErasePoseMarker(reader);
      break;
    case Tag.VisualizeQuad:
      VisualizeQuad = new Anki.Vector.ExternalInterface.VisualizeQuad(reader);
      break;
    case Tag.EraseQuad:
      EraseQuad = new Anki.Vector.ExternalInterface.EraseQuad(reader);
      break;
    case Tag.ReadAnimationFile:
      ReadAnimationFile = new Anki.Vector.ExternalInterface.ReadAnimationFile(reader);
      break;
    case Tag.RequestAvailableAnimationGroups:
      RequestAvailableAnimationGroups = new Anki.Vector.ExternalInterface.RequestAvailableAnimationGroups(reader);
      break;
    case Tag.PushDrivingAnimations:
      PushDrivingAnimations = new Anki.Vector.ExternalInterface.PushDrivingAnimations(reader);
      break;
    case Tag.RemoveDrivingAnimations:
      RemoveDrivingAnimations = new Anki.Vector.ExternalInterface.RemoveDrivingAnimations(reader);
      break;
    case Tag.DisplayProceduralFace:
      DisplayProceduralFace = new Anki.Vector.ExternalInterface.DisplayProceduralFace(reader);
      break;
    case Tag.SetFaceHue:
      SetFaceHue = new Anki.Vector.ExternalInterface.SetFaceHue(reader);
      break;
    case Tag.DisplayFaceImageBinaryChunk:
      DisplayFaceImageBinaryChunk = new Anki.Vector.ExternalInterface.DisplayFaceImageBinaryChunk(reader);
      break;
    case Tag.SetActiveObjectLEDs:
      SetActiveObjectLEDs = new Anki.Vector.ExternalInterface.SetActiveObjectLEDs(reader);
      break;
    case Tag.SetAllActiveObjectLEDs:
      SetAllActiveObjectLEDs = new Anki.Vector.ExternalInterface.SetAllActiveObjectLEDs(reader);
      break;
    case Tag.SetBackpackLEDs:
      SetBackpackLEDs = new Anki.Vector.ExternalInterface.SetBackpackLEDs(reader);
      break;
    case Tag.EnableLightStates:
      EnableLightStates = new Anki.Vector.ExternalInterface.EnableLightStates(reader);
      break;
    case Tag.PlayCubeAnim:
      PlayCubeAnim = new Anki.Vector.ExternalInterface.PlayCubeAnim(reader);
      break;
    case Tag.StopCubeAnim:
      StopCubeAnim = new Anki.Vector.ExternalInterface.StopCubeAnim(reader);
      break;
    case Tag.SetOnboardingStage:
      SetOnboardingStage = new Anki.Vector.ExternalInterface.SetOnboardingStage(reader);
      break;
    case Tag.MoodMessage:
      MoodMessage = new Anki.Vector.ExternalInterface.MoodMessage(reader);
      break;
    case Tag.SetDebugConsoleVarMessage:
      SetDebugConsoleVarMessage = new Anki.Vector.ExternalInterface.SetDebugConsoleVarMessage(reader);
      break;
    case Tag.SetAnimDebugConsoleVarMessage:
      SetAnimDebugConsoleVarMessage = new Anki.Vector.ExternalInterface.SetAnimDebugConsoleVarMessage(reader);
      break;
    case Tag.RunDebugConsoleFuncMessage:
      RunDebugConsoleFuncMessage = new Anki.Vector.ExternalInterface.RunDebugConsoleFuncMessage(reader);
      break;
    case Tag.RunAnimDebugConsoleFuncMessage:
      RunAnimDebugConsoleFuncMessage = new Anki.Vector.ExternalInterface.RunAnimDebugConsoleFuncMessage(reader);
      break;
    case Tag.GetDebugConsoleVarMessage:
      GetDebugConsoleVarMessage = new Anki.Vector.ExternalInterface.GetDebugConsoleVarMessage(reader);
      break;
    case Tag.GetAllDebugConsoleVarMessage:
      GetAllDebugConsoleVarMessage = new Anki.Vector.ExternalInterface.GetAllDebugConsoleVarMessage(reader);
      break;
    case Tag.GetJsonDasLogsMessage:
      GetJsonDasLogsMessage = new Anki.Vector.ExternalInterface.GetJsonDasLogsMessage(reader);
      break;
    case Tag.SetEnableSpeedChooser:
      SetEnableSpeedChooser = new Anki.Vector.ExternalInterface.SetEnableSpeedChooser(reader);
      break;
    case Tag.LogRawCliffData:
      LogRawCliffData = new Anki.Vector.ExternalInterface.LogRawCliffData(reader);
      break;
    case Tag.LogRawProxData:
      LogRawProxData = new Anki.Vector.ExternalInterface.LogRawProxData(reader);
      break;
    case Tag.ConnectToCube:
      ConnectToCube = new Anki.Vector.ExternalInterface.ConnectToCube(reader);
      break;
    case Tag.DisconnectFromCube:
      DisconnectFromCube = new Anki.Vector.ExternalInterface.DisconnectFromCube(reader);
      break;
    case Tag.ForgetPreferredCube:
      ForgetPreferredCube = new Anki.Vector.ExternalInterface.ForgetPreferredCube(reader);
      break;
    case Tag.SetPreferredCube:
      SetPreferredCube = new Anki.Vector.ExternalInterface.SetPreferredCube(reader);
      break;
    case Tag.SendAvailableObjects:
      SendAvailableObjects = new Anki.Vector.ExternalInterface.SendAvailableObjects(reader);
      break;
    case Tag.SaveCalibrationImage:
      SaveCalibrationImage = new Anki.Vector.ExternalInterface.SaveCalibrationImage(reader);
      break;
    case Tag.ClearCalibrationImages:
      ClearCalibrationImages = new Anki.Vector.ExternalInterface.ClearCalibrationImages(reader);
      break;
    case Tag.ComputeCameraCalibration:
      ComputeCameraCalibration = new Anki.Vector.ExternalInterface.ComputeCameraCalibration(reader);
      break;
    case Tag.TransferFile:
      TransferFile = new Anki.Vector.ExternalInterface.TransferFile(reader);
      break;
    case Tag.SetCameraSettings:
      SetCameraSettings = new Anki.Vector.ExternalInterface.SetCameraSettings(reader);
      break;
    case Tag.RequestRobotSettings:
      RequestRobotSettings = new Anki.Vector.ExternalInterface.RequestRobotSettings(reader);
      break;
    default:
      break;

    }
    _tag = newTag;
  }

  public void Pack(System.IO.Stream stream)
  {
    System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
    Pack(writer);
  }

  public void Pack(System.IO.BinaryWriter writer)
  {
    writer.Write((byte)GetTag());
    switch(GetTag()) {
    case Tag.UiDeviceConnectionWrongVersion:
      if (UiDeviceConnectionWrongVersion == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      UiDeviceConnectionWrongVersion.Pack(writer);
      break;
    case Tag.MoveHead:
      if (MoveHead == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      MoveHead.Pack(writer);
      break;
    case Tag.MoveLift:
      if (MoveLift == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      MoveLift.Pack(writer);
      break;
    case Tag.DriveArc:
      if (DriveArc == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DriveArc.Pack(writer);
      break;
    case Tag.RobotHistoryRequest:
      if (RobotHistoryRequest == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RobotHistoryRequest.Pack(writer);
      break;
    case Tag.DisplayFaceImageRGBChunk:
      if (DisplayFaceImageRGBChunk == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DisplayFaceImageRGBChunk.Pack(writer);
      break;
    case Tag.AppIntent:
      if (AppIntent == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AppIntent.Pack(writer);
      break;
    case Tag.CancelFaceEnrollment:
      if (CancelFaceEnrollment == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CancelFaceEnrollment.Pack(writer);
      break;
    case Tag.RequestEnrolledNames:
      if (RequestEnrolledNames == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RequestEnrolledNames.Pack(writer);
      break;
    case Tag.UpdateEnrolledFaceByID:
      if (UpdateEnrolledFaceByID == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      UpdateEnrolledFaceByID.Pack(writer);
      break;
    case Tag.EraseEnrolledFaceByID:
      if (EraseEnrolledFaceByID == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EraseEnrolledFaceByID.Pack(writer);
      break;
    case Tag.EraseAllEnrolledFaces:
      if (EraseAllEnrolledFaces == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EraseAllEnrolledFaces.Pack(writer);
      break;
    case Tag.SetFaceToEnroll:
      if (SetFaceToEnroll == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetFaceToEnroll.Pack(writer);
      break;
    case Tag.EnableVisionMode:
      if (EnableVisionMode == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableVisionMode.Pack(writer);
      break;
    case Tag.RequestAvailableAnimations:
      if (RequestAvailableAnimations == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RequestAvailableAnimations.Pack(writer);
      break;
    case Tag.GotoPose:
      if (GotoPose == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GotoPose.Pack(writer);
      break;
    case Tag.DriveStraight:
      if (DriveStraight == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DriveStraight.Pack(writer);
      break;
    case Tag.TurnInPlace:
      if (TurnInPlace == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnInPlace.Pack(writer);
      break;
    case Tag.SetHeadAngle:
      if (SetHeadAngle == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetHeadAngle.Pack(writer);
      break;
    case Tag.SetLiftHeight:
      if (SetLiftHeight == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetLiftHeight.Pack(writer);
      break;
    case Tag.AlignWithObject:
      if (AlignWithObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AlignWithObject.Pack(writer);
      break;
    case Tag.SetLiftAngle:
      if (SetLiftAngle == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetLiftAngle.Pack(writer);
      break;
    case Tag.DeleteCustomMarkerObjects:
      if (DeleteCustomMarkerObjects == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DeleteCustomMarkerObjects.Pack(writer);
      break;
    case Tag.DeleteFixedCustomObjects:
      if (DeleteFixedCustomObjects == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DeleteFixedCustomObjects.Pack(writer);
      break;
    case Tag.UndefineAllCustomMarkerObjects:
      if (UndefineAllCustomMarkerObjects == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      UndefineAllCustomMarkerObjects.Pack(writer);
      break;
    case Tag.CreateFixedCustomObject:
      if (CreateFixedCustomObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CreateFixedCustomObject.Pack(writer);
      break;
    case Tag.DefineCustomBox:
      if (DefineCustomBox == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DefineCustomBox.Pack(writer);
      break;
    case Tag.DefineCustomCube:
      if (DefineCustomCube == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DefineCustomCube.Pack(writer);
      break;
    case Tag.DefineCustomWall:
      if (DefineCustomWall == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DefineCustomWall.Pack(writer);
      break;
    case Tag.SetMemoryMapBroadcastFrequency_sec:
      if (SetMemoryMapBroadcastFrequency_sec == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetMemoryMapBroadcastFrequency_sec.Pack(writer);
      break;
    case Tag.PostAudioEvent:
      if (PostAudioEvent == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PostAudioEvent.Pack(writer);
      break;
    case Tag.StopAllAudioEvents:
      if (StopAllAudioEvents == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      StopAllAudioEvents.Pack(writer);
      break;
    case Tag.PostAudioGameState:
      if (PostAudioGameState == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PostAudioGameState.Pack(writer);
      break;
    case Tag.PostAudioSwitchState:
      if (PostAudioSwitchState == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PostAudioSwitchState.Pack(writer);
      break;
    case Tag.PostAudioParameter:
      if (PostAudioParameter == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PostAudioParameter.Pack(writer);
      break;
    case Tag.PostAudioMusicState:
      if (PostAudioMusicState == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PostAudioMusicState.Pack(writer);
      break;
    case Tag.CalibrateMotors:
      if (CalibrateMotors == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CalibrateMotors.Pack(writer);
      break;
    case Tag.CliffAlignToWhite:
      if (CliffAlignToWhite == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CliffAlignToWhite.Pack(writer);
      break;
    case Tag.FlipBlock:
      if (FlipBlock == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      FlipBlock.Pack(writer);
      break;
    case Tag.GotoObject:
      if (GotoObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GotoObject.Pack(writer);
      break;
    case Tag.MountCharger:
      if (MountCharger == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      MountCharger.Pack(writer);
      break;
    case Tag.PanAndTilt:
      if (PanAndTilt == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PanAndTilt.Pack(writer);
      break;
    case Tag.PickupObject:
      if (PickupObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PickupObject.Pack(writer);
      break;
    case Tag.PlaceObjectOnGround:
      if (PlaceObjectOnGround == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlaceObjectOnGround.Pack(writer);
      break;
    case Tag.PlaceObjectOnGroundHere:
      if (PlaceObjectOnGroundHere == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlaceObjectOnGroundHere.Pack(writer);
      break;
    case Tag.PlaceOnObject:
      if (PlaceOnObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlaceOnObject.Pack(writer);
      break;
    case Tag.PlaceRelObject:
      if (PlaceRelObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlaceRelObject.Pack(writer);
      break;
    case Tag.PlayAnimation:
      if (PlayAnimation == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlayAnimation.Pack(writer);
      break;
    case Tag.ListAnimations:
      if (ListAnimations == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ListAnimations.Pack(writer);
      break;
    case Tag.PlayAnimationGroup:
      if (PlayAnimationGroup == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlayAnimationGroup.Pack(writer);
      break;
    case Tag.PlayAnimationTrigger:
      if (PlayAnimationTrigger == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlayAnimationTrigger.Pack(writer);
      break;
    case Tag.PopAWheelie:
      if (PopAWheelie == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PopAWheelie.Pack(writer);
      break;
    case Tag.FacePlant:
      if (FacePlant == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      FacePlant.Pack(writer);
      break;
    case Tag.RealignWithObject:
      if (RealignWithObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RealignWithObject.Pack(writer);
      break;
    case Tag.RollObject:
      if (RollObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RollObject.Pack(writer);
      break;
    case Tag.SayText:
      if (SayText == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SayText.Pack(writer);
      break;
    case Tag.SearchForNearbyObject:
      if (SearchForNearbyObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SearchForNearbyObject.Pack(writer);
      break;
    case Tag.TrackToFace:
      if (TrackToFace == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TrackToFace.Pack(writer);
      break;
    case Tag.TrackToObject:
      if (TrackToObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TrackToObject.Pack(writer);
      break;
    case Tag.TrackToLaserPoint:
      if (TrackToLaserPoint == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TrackToLaserPoint.Pack(writer);
      break;
    case Tag.TrackToPet:
      if (TrackToPet == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TrackToPet.Pack(writer);
      break;
    case Tag.TurnInPlaceAtSpeed:
      if (TurnInPlaceAtSpeed == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnInPlaceAtSpeed.Pack(writer);
      break;
    case Tag.TurnTowardsFace:
      if (TurnTowardsFace == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnTowardsFace.Pack(writer);
      break;
    case Tag.TurnTowardsImagePoint:
      if (TurnTowardsImagePoint == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnTowardsImagePoint.Pack(writer);
      break;
    case Tag.TurnTowardsLastFacePose:
      if (TurnTowardsLastFacePose == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnTowardsLastFacePose.Pack(writer);
      break;
    case Tag.TurnTowardsObject:
      if (TurnTowardsObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnTowardsObject.Pack(writer);
      break;
    case Tag.TurnTowardsPose:
      if (TurnTowardsPose == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TurnTowardsPose.Pack(writer);
      break;
    case Tag.VisuallyVerifyFace:
      if (VisuallyVerifyFace == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisuallyVerifyFace.Pack(writer);
      break;
    case Tag.VisuallyVerifyObject:
      if (VisuallyVerifyObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisuallyVerifyObject.Pack(writer);
      break;
    case Tag.VisuallyVerifyNoObjectAtPose:
      if (VisuallyVerifyNoObjectAtPose == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisuallyVerifyNoObjectAtPose.Pack(writer);
      break;
    case Tag.Wait:
      if (Wait == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      Wait.Pack(writer);
      break;
    case Tag.WaitForImages:
      if (WaitForImages == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      WaitForImages.Pack(writer);
      break;
    case Tag.AdvertisementRegistrationMsg:
      if (AdvertisementRegistrationMsg == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AdvertisementRegistrationMsg.Pack(writer);
      break;
    case Tag.AdvertisementMsg:
      if (AdvertisementMsg == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AdvertisementMsg.Pack(writer);
      break;
    case Tag.Ping:
      if (Ping == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      Ping.Pack(writer);
      break;
    case Tag.SetVizOrigin:
      if (SetVizOrigin == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetVizOrigin.Pack(writer);
      break;
    case Tag.ImageChunk:
      if (ImageChunk == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ImageChunk.Pack(writer);
      break;
    case Tag.CameraCalibration:
      if (CameraCalibration == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CameraCalibration.Pack(writer);
      break;
    case Tag.IMURequest:
      if (IMURequest == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      IMURequest.Pack(writer);
      break;
    case Tag.IMUTemperature:
      if (IMUTemperature == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      IMUTemperature.Pack(writer);
      break;
    case Tag.StartControllerTestMode:
      if (StartControllerTestMode == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      StartControllerTestMode.Pack(writer);
      break;
    case Tag.RawPWM:
      if (RawPWM == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RawPWM.Pack(writer);
      break;
    case Tag.SetConnectionStatus:
      if (SetConnectionStatus == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetConnectionStatus.Pack(writer);
      break;
    case Tag.SendBLEConnectionStatus:
      if (SendBLEConnectionStatus == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SendBLEConnectionStatus.Pack(writer);
      break;
    case Tag.SetBLEPin:
      if (SetBLEPin == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetBLEPin.Pack(writer);
      break;
    case Tag.WifiScanResponse:
      if (WifiScanResponse == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      WifiScanResponse.Pack(writer);
      break;
    case Tag.WifiConnectResponse:
      if (WifiConnectResponse == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      WifiConnectResponse.Pack(writer);
      break;
    case Tag.HasBleKeysResponse:
      if (HasBleKeysResponse == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      HasBleKeysResponse.Pack(writer);
      break;
    case Tag.ActivateExperimentRequest:
      if (ActivateExperimentRequest == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ActivateExperimentRequest.Pack(writer);
      break;
    case Tag.ActivateExperimentResponse:
      if (ActivateExperimentResponse == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ActivateExperimentResponse.Pack(writer);
      break;
    case Tag.ConnectToUiDevice:
      if (ConnectToUiDevice == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ConnectToUiDevice.Pack(writer);
      break;
    case Tag.DisconnectFromUiDevice:
      if (DisconnectFromUiDevice == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DisconnectFromUiDevice.Pack(writer);
      break;
    case Tag.UserLoggedIn:
      if (UserLoggedIn == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      UserLoggedIn.Pack(writer);
      break;
    case Tag.DriveWheels:
      if (DriveWheels == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DriveWheels.Pack(writer);
      break;
    case Tag.EnableLiftPower:
      if (EnableLiftPower == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableLiftPower.Pack(writer);
      break;
    case Tag.EnableCliffSensor:
      if (EnableCliffSensor == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableCliffSensor.Pack(writer);
      break;
    case Tag.EnableStopOnCliff:
      if (EnableStopOnCliff == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableStopOnCliff.Pack(writer);
      break;
    case Tag.StopAllMotors:
      if (StopAllMotors == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      StopAllMotors.Pack(writer);
      break;
    case Tag.ControllerGains:
      if (ControllerGains == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ControllerGains.Pack(writer);
      break;
    case Tag.RollActionParams:
      if (RollActionParams == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RollActionParams.Pack(writer);
      break;
    case Tag.SetMotionModelParams:
      if (SetMotionModelParams == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetMotionModelParams.Pack(writer);
      break;
    case Tag.SetRobotVolume:
      if (SetRobotVolume == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetRobotVolume.Pack(writer);
      break;
    case Tag.ForceDelocalizeRobot:
      if (ForceDelocalizeRobot == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ForceDelocalizeRobot.Pack(writer);
      break;
    case Tag.CancelAction:
      if (CancelAction == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CancelAction.Pack(writer);
      break;
    case Tag.CancelActionByIdTag:
      if (CancelActionByIdTag == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      CancelActionByIdTag.Pack(writer);
      break;
    case Tag.QueueSingleAction:
      if (QueueSingleAction == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      QueueSingleAction.Pack(writer);
      break;
    case Tag.QueueCompoundAction:
      if (QueueCompoundAction == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      QueueCompoundAction.Pack(writer);
      break;
    case Tag.RedirectViz:
      if (RedirectViz == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RedirectViz.Pack(writer);
      break;
    case Tag.ImageRequest:
      if (ImageRequest == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ImageRequest.Pack(writer);
      break;
    case Tag.SaveImages:
      if (SaveImages == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SaveImages.Pack(writer);
      break;
    case Tag.EnableColorImages:
      if (EnableColorImages == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableColorImages.Pack(writer);
      break;
    case Tag.SaveRobotState:
      if (SaveRobotState == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SaveRobotState.Pack(writer);
      break;
    case Tag.EnableDisplay:
      if (EnableDisplay == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableDisplay.Pack(writer);
      break;
    case Tag.ExecuteTestPlan:
      if (ExecuteTestPlan == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ExecuteTestPlan.Pack(writer);
      break;
    case Tag.SelectNextObject:
      if (SelectNextObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SelectNextObject.Pack(writer);
      break;
    case Tag.SetRobotCarryingObject:
      if (SetRobotCarryingObject == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetRobotCarryingObject.Pack(writer);
      break;
    case Tag.DeleteAllCustomObjects:
      if (DeleteAllCustomObjects == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DeleteAllCustomObjects.Pack(writer);
      break;
    case Tag.VisionWhileMoving:
      if (VisionWhileMoving == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisionWhileMoving.Pack(writer);
      break;
    case Tag.VisionRunMode:
      if (VisionRunMode == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisionRunMode.Pack(writer);
      break;
    case Tag.SaveFaceAlbumToFile:
      if (SaveFaceAlbumToFile == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SaveFaceAlbumToFile.Pack(writer);
      break;
    case Tag.LoadFaceAlbumFromFile:
      if (LoadFaceAlbumFromFile == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      LoadFaceAlbumFromFile.Pack(writer);
      break;
    case Tag.SetCameraCaptureFormat:
      if (SetCameraCaptureFormat == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetCameraCaptureFormat.Pack(writer);
      break;
    case Tag.SetMemoryMapRenderEnabled:
      if (SetMemoryMapRenderEnabled == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetMemoryMapRenderEnabled.Pack(writer);
      break;
    case Tag.FakeTriggerWordDetected:
      if (FakeTriggerWordDetected == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      FakeTriggerWordDetected.Pack(writer);
      break;
    case Tag.FakeCloudIntent:
      if (FakeCloudIntent == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      FakeCloudIntent.Pack(writer);
      break;
    case Tag.FakeUserIntent:
      if (FakeUserIntent == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      FakeUserIntent.Pack(writer);
      break;
    case Tag.ExecuteBehaviorByID:
      if (ExecuteBehaviorByID == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ExecuteBehaviorByID.Pack(writer);
      break;
    case Tag.SetLiftLoadTestAsActivatable:
      if (SetLiftLoadTestAsActivatable == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetLiftLoadTestAsActivatable.Pack(writer);
      break;
    case Tag.AbortPath:
      if (AbortPath == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AbortPath.Pack(writer);
      break;
    case Tag.AbortAll:
      if (AbortAll == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      AbortAll.Pack(writer);
      break;
    case Tag.StartTestMode:
      if (StartTestMode == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      StartTestMode.Pack(writer);
      break;
    case Tag.DrawPoseMarker:
      if (DrawPoseMarker == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DrawPoseMarker.Pack(writer);
      break;
    case Tag.ErasePoseMarker:
      if (ErasePoseMarker == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ErasePoseMarker.Pack(writer);
      break;
    case Tag.VisualizeQuad:
      if (VisualizeQuad == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      VisualizeQuad.Pack(writer);
      break;
    case Tag.EraseQuad:
      if (EraseQuad == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EraseQuad.Pack(writer);
      break;
    case Tag.ReadAnimationFile:
      if (ReadAnimationFile == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ReadAnimationFile.Pack(writer);
      break;
    case Tag.RequestAvailableAnimationGroups:
      if (RequestAvailableAnimationGroups == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RequestAvailableAnimationGroups.Pack(writer);
      break;
    case Tag.PushDrivingAnimations:
      if (PushDrivingAnimations == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PushDrivingAnimations.Pack(writer);
      break;
    case Tag.RemoveDrivingAnimations:
      if (RemoveDrivingAnimations == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RemoveDrivingAnimations.Pack(writer);
      break;
    case Tag.DisplayProceduralFace:
      if (DisplayProceduralFace == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DisplayProceduralFace.Pack(writer);
      break;
    case Tag.SetFaceHue:
      if (SetFaceHue == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetFaceHue.Pack(writer);
      break;
    case Tag.DisplayFaceImageBinaryChunk:
      if (DisplayFaceImageBinaryChunk == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DisplayFaceImageBinaryChunk.Pack(writer);
      break;
    case Tag.SetActiveObjectLEDs:
      if (SetActiveObjectLEDs == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetActiveObjectLEDs.Pack(writer);
      break;
    case Tag.SetAllActiveObjectLEDs:
      if (SetAllActiveObjectLEDs == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetAllActiveObjectLEDs.Pack(writer);
      break;
    case Tag.SetBackpackLEDs:
      if (SetBackpackLEDs == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetBackpackLEDs.Pack(writer);
      break;
    case Tag.EnableLightStates:
      if (EnableLightStates == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      EnableLightStates.Pack(writer);
      break;
    case Tag.PlayCubeAnim:
      if (PlayCubeAnim == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      PlayCubeAnim.Pack(writer);
      break;
    case Tag.StopCubeAnim:
      if (StopCubeAnim == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      StopCubeAnim.Pack(writer);
      break;
    case Tag.SetOnboardingStage:
      if (SetOnboardingStage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetOnboardingStage.Pack(writer);
      break;
    case Tag.MoodMessage:
      if (MoodMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      MoodMessage.Pack(writer);
      break;
    case Tag.SetDebugConsoleVarMessage:
      if (SetDebugConsoleVarMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetDebugConsoleVarMessage.Pack(writer);
      break;
    case Tag.SetAnimDebugConsoleVarMessage:
      if (SetAnimDebugConsoleVarMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetAnimDebugConsoleVarMessage.Pack(writer);
      break;
    case Tag.RunDebugConsoleFuncMessage:
      if (RunDebugConsoleFuncMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RunDebugConsoleFuncMessage.Pack(writer);
      break;
    case Tag.RunAnimDebugConsoleFuncMessage:
      if (RunAnimDebugConsoleFuncMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RunAnimDebugConsoleFuncMessage.Pack(writer);
      break;
    case Tag.GetDebugConsoleVarMessage:
      if (GetDebugConsoleVarMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GetDebugConsoleVarMessage.Pack(writer);
      break;
    case Tag.GetAllDebugConsoleVarMessage:
      if (GetAllDebugConsoleVarMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GetAllDebugConsoleVarMessage.Pack(writer);
      break;
    case Tag.GetJsonDasLogsMessage:
      if (GetJsonDasLogsMessage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      GetJsonDasLogsMessage.Pack(writer);
      break;
    case Tag.SetEnableSpeedChooser:
      if (SetEnableSpeedChooser == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetEnableSpeedChooser.Pack(writer);
      break;
    case Tag.LogRawCliffData:
      if (LogRawCliffData == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      LogRawCliffData.Pack(writer);
      break;
    case Tag.LogRawProxData:
      if (LogRawProxData == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      LogRawProxData.Pack(writer);
      break;
    case Tag.ConnectToCube:
      if (ConnectToCube == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ConnectToCube.Pack(writer);
      break;
    case Tag.DisconnectFromCube:
      if (DisconnectFromCube == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      DisconnectFromCube.Pack(writer);
      break;
    case Tag.ForgetPreferredCube:
      if (ForgetPreferredCube == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ForgetPreferredCube.Pack(writer);
      break;
    case Tag.SetPreferredCube:
      if (SetPreferredCube == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetPreferredCube.Pack(writer);
      break;
    case Tag.SendAvailableObjects:
      if (SendAvailableObjects == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SendAvailableObjects.Pack(writer);
      break;
    case Tag.SaveCalibrationImage:
      if (SaveCalibrationImage == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SaveCalibrationImage.Pack(writer);
      break;
    case Tag.ClearCalibrationImages:
      if (ClearCalibrationImages == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ClearCalibrationImages.Pack(writer);
      break;
    case Tag.ComputeCameraCalibration:
      if (ComputeCameraCalibration == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      ComputeCameraCalibration.Pack(writer);
      break;
    case Tag.TransferFile:
      if (TransferFile == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      TransferFile.Pack(writer);
      break;
    case Tag.SetCameraSettings:
      if (SetCameraSettings == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      SetCameraSettings.Pack(writer);
      break;
    case Tag.RequestRobotSettings:
      if (RequestRobotSettings == null) {
        throw new System.InvalidOperationException("Arrays in messages may not have null entries.");
      }
      RequestRobotSettings.Pack(writer);
      break;
    default:
      break;
    }
  }

  public int Size
  {
    get {
      int result = 1; // tag = byte
      switch(GetTag()) {
      case Tag.UiDeviceConnectionWrongVersion:
        if (UiDeviceConnectionWrongVersion == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += UiDeviceConnectionWrongVersion.Size;
        break;
      case Tag.MoveHead:
        if (MoveHead == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += MoveHead.Size;
        break;
      case Tag.MoveLift:
        if (MoveLift == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += MoveLift.Size;
        break;
      case Tag.DriveArc:
        if (DriveArc == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DriveArc.Size;
        break;
      case Tag.RobotHistoryRequest:
        if (RobotHistoryRequest == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RobotHistoryRequest.Size;
        break;
      case Tag.DisplayFaceImageRGBChunk:
        if (DisplayFaceImageRGBChunk == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DisplayFaceImageRGBChunk.Size;
        break;
      case Tag.AppIntent:
        if (AppIntent == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AppIntent.Size;
        break;
      case Tag.CancelFaceEnrollment:
        if (CancelFaceEnrollment == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CancelFaceEnrollment.Size;
        break;
      case Tag.RequestEnrolledNames:
        if (RequestEnrolledNames == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RequestEnrolledNames.Size;
        break;
      case Tag.UpdateEnrolledFaceByID:
        if (UpdateEnrolledFaceByID == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += UpdateEnrolledFaceByID.Size;
        break;
      case Tag.EraseEnrolledFaceByID:
        if (EraseEnrolledFaceByID == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EraseEnrolledFaceByID.Size;
        break;
      case Tag.EraseAllEnrolledFaces:
        if (EraseAllEnrolledFaces == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EraseAllEnrolledFaces.Size;
        break;
      case Tag.SetFaceToEnroll:
        if (SetFaceToEnroll == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetFaceToEnroll.Size;
        break;
      case Tag.EnableVisionMode:
        if (EnableVisionMode == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableVisionMode.Size;
        break;
      case Tag.RequestAvailableAnimations:
        if (RequestAvailableAnimations == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RequestAvailableAnimations.Size;
        break;
      case Tag.GotoPose:
        if (GotoPose == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GotoPose.Size;
        break;
      case Tag.DriveStraight:
        if (DriveStraight == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DriveStraight.Size;
        break;
      case Tag.TurnInPlace:
        if (TurnInPlace == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnInPlace.Size;
        break;
      case Tag.SetHeadAngle:
        if (SetHeadAngle == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetHeadAngle.Size;
        break;
      case Tag.SetLiftHeight:
        if (SetLiftHeight == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetLiftHeight.Size;
        break;
      case Tag.AlignWithObject:
        if (AlignWithObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AlignWithObject.Size;
        break;
      case Tag.SetLiftAngle:
        if (SetLiftAngle == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetLiftAngle.Size;
        break;
      case Tag.DeleteCustomMarkerObjects:
        if (DeleteCustomMarkerObjects == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DeleteCustomMarkerObjects.Size;
        break;
      case Tag.DeleteFixedCustomObjects:
        if (DeleteFixedCustomObjects == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DeleteFixedCustomObjects.Size;
        break;
      case Tag.UndefineAllCustomMarkerObjects:
        if (UndefineAllCustomMarkerObjects == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += UndefineAllCustomMarkerObjects.Size;
        break;
      case Tag.CreateFixedCustomObject:
        if (CreateFixedCustomObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CreateFixedCustomObject.Size;
        break;
      case Tag.DefineCustomBox:
        if (DefineCustomBox == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DefineCustomBox.Size;
        break;
      case Tag.DefineCustomCube:
        if (DefineCustomCube == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DefineCustomCube.Size;
        break;
      case Tag.DefineCustomWall:
        if (DefineCustomWall == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DefineCustomWall.Size;
        break;
      case Tag.SetMemoryMapBroadcastFrequency_sec:
        if (SetMemoryMapBroadcastFrequency_sec == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetMemoryMapBroadcastFrequency_sec.Size;
        break;
      case Tag.PostAudioEvent:
        if (PostAudioEvent == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PostAudioEvent.Size;
        break;
      case Tag.StopAllAudioEvents:
        if (StopAllAudioEvents == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += StopAllAudioEvents.Size;
        break;
      case Tag.PostAudioGameState:
        if (PostAudioGameState == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PostAudioGameState.Size;
        break;
      case Tag.PostAudioSwitchState:
        if (PostAudioSwitchState == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PostAudioSwitchState.Size;
        break;
      case Tag.PostAudioParameter:
        if (PostAudioParameter == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PostAudioParameter.Size;
        break;
      case Tag.PostAudioMusicState:
        if (PostAudioMusicState == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PostAudioMusicState.Size;
        break;
      case Tag.CalibrateMotors:
        if (CalibrateMotors == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CalibrateMotors.Size;
        break;
      case Tag.CliffAlignToWhite:
        if (CliffAlignToWhite == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CliffAlignToWhite.Size;
        break;
      case Tag.FlipBlock:
        if (FlipBlock == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += FlipBlock.Size;
        break;
      case Tag.GotoObject:
        if (GotoObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GotoObject.Size;
        break;
      case Tag.MountCharger:
        if (MountCharger == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += MountCharger.Size;
        break;
      case Tag.PanAndTilt:
        if (PanAndTilt == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PanAndTilt.Size;
        break;
      case Tag.PickupObject:
        if (PickupObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PickupObject.Size;
        break;
      case Tag.PlaceObjectOnGround:
        if (PlaceObjectOnGround == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlaceObjectOnGround.Size;
        break;
      case Tag.PlaceObjectOnGroundHere:
        if (PlaceObjectOnGroundHere == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlaceObjectOnGroundHere.Size;
        break;
      case Tag.PlaceOnObject:
        if (PlaceOnObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlaceOnObject.Size;
        break;
      case Tag.PlaceRelObject:
        if (PlaceRelObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlaceRelObject.Size;
        break;
      case Tag.PlayAnimation:
        if (PlayAnimation == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlayAnimation.Size;
        break;
      case Tag.ListAnimations:
        if (ListAnimations == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ListAnimations.Size;
        break;
      case Tag.PlayAnimationGroup:
        if (PlayAnimationGroup == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlayAnimationGroup.Size;
        break;
      case Tag.PlayAnimationTrigger:
        if (PlayAnimationTrigger == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlayAnimationTrigger.Size;
        break;
      case Tag.PopAWheelie:
        if (PopAWheelie == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PopAWheelie.Size;
        break;
      case Tag.FacePlant:
        if (FacePlant == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += FacePlant.Size;
        break;
      case Tag.RealignWithObject:
        if (RealignWithObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RealignWithObject.Size;
        break;
      case Tag.RollObject:
        if (RollObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RollObject.Size;
        break;
      case Tag.SayText:
        if (SayText == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SayText.Size;
        break;
      case Tag.SearchForNearbyObject:
        if (SearchForNearbyObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SearchForNearbyObject.Size;
        break;
      case Tag.TrackToFace:
        if (TrackToFace == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TrackToFace.Size;
        break;
      case Tag.TrackToObject:
        if (TrackToObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TrackToObject.Size;
        break;
      case Tag.TrackToLaserPoint:
        if (TrackToLaserPoint == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TrackToLaserPoint.Size;
        break;
      case Tag.TrackToPet:
        if (TrackToPet == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TrackToPet.Size;
        break;
      case Tag.TurnInPlaceAtSpeed:
        if (TurnInPlaceAtSpeed == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnInPlaceAtSpeed.Size;
        break;
      case Tag.TurnTowardsFace:
        if (TurnTowardsFace == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnTowardsFace.Size;
        break;
      case Tag.TurnTowardsImagePoint:
        if (TurnTowardsImagePoint == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnTowardsImagePoint.Size;
        break;
      case Tag.TurnTowardsLastFacePose:
        if (TurnTowardsLastFacePose == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnTowardsLastFacePose.Size;
        break;
      case Tag.TurnTowardsObject:
        if (TurnTowardsObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnTowardsObject.Size;
        break;
      case Tag.TurnTowardsPose:
        if (TurnTowardsPose == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TurnTowardsPose.Size;
        break;
      case Tag.VisuallyVerifyFace:
        if (VisuallyVerifyFace == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisuallyVerifyFace.Size;
        break;
      case Tag.VisuallyVerifyObject:
        if (VisuallyVerifyObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisuallyVerifyObject.Size;
        break;
      case Tag.VisuallyVerifyNoObjectAtPose:
        if (VisuallyVerifyNoObjectAtPose == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisuallyVerifyNoObjectAtPose.Size;
        break;
      case Tag.Wait:
        if (Wait == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += Wait.Size;
        break;
      case Tag.WaitForImages:
        if (WaitForImages == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += WaitForImages.Size;
        break;
      case Tag.AdvertisementRegistrationMsg:
        if (AdvertisementRegistrationMsg == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AdvertisementRegistrationMsg.Size;
        break;
      case Tag.AdvertisementMsg:
        if (AdvertisementMsg == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AdvertisementMsg.Size;
        break;
      case Tag.Ping:
        if (Ping == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += Ping.Size;
        break;
      case Tag.SetVizOrigin:
        if (SetVizOrigin == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetVizOrigin.Size;
        break;
      case Tag.ImageChunk:
        if (ImageChunk == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ImageChunk.Size;
        break;
      case Tag.CameraCalibration:
        if (CameraCalibration == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CameraCalibration.Size;
        break;
      case Tag.IMURequest:
        if (IMURequest == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += IMURequest.Size;
        break;
      case Tag.IMUTemperature:
        if (IMUTemperature == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += IMUTemperature.Size;
        break;
      case Tag.StartControllerTestMode:
        if (StartControllerTestMode == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += StartControllerTestMode.Size;
        break;
      case Tag.RawPWM:
        if (RawPWM == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RawPWM.Size;
        break;
      case Tag.SetConnectionStatus:
        if (SetConnectionStatus == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetConnectionStatus.Size;
        break;
      case Tag.SendBLEConnectionStatus:
        if (SendBLEConnectionStatus == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SendBLEConnectionStatus.Size;
        break;
      case Tag.SetBLEPin:
        if (SetBLEPin == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetBLEPin.Size;
        break;
      case Tag.WifiScanResponse:
        if (WifiScanResponse == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += WifiScanResponse.Size;
        break;
      case Tag.WifiConnectResponse:
        if (WifiConnectResponse == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += WifiConnectResponse.Size;
        break;
      case Tag.HasBleKeysResponse:
        if (HasBleKeysResponse == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += HasBleKeysResponse.Size;
        break;
      case Tag.ActivateExperimentRequest:
        if (ActivateExperimentRequest == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ActivateExperimentRequest.Size;
        break;
      case Tag.ActivateExperimentResponse:
        if (ActivateExperimentResponse == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ActivateExperimentResponse.Size;
        break;
      case Tag.ConnectToUiDevice:
        if (ConnectToUiDevice == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ConnectToUiDevice.Size;
        break;
      case Tag.DisconnectFromUiDevice:
        if (DisconnectFromUiDevice == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DisconnectFromUiDevice.Size;
        break;
      case Tag.UserLoggedIn:
        if (UserLoggedIn == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += UserLoggedIn.Size;
        break;
      case Tag.DriveWheels:
        if (DriveWheels == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DriveWheels.Size;
        break;
      case Tag.EnableLiftPower:
        if (EnableLiftPower == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableLiftPower.Size;
        break;
      case Tag.EnableCliffSensor:
        if (EnableCliffSensor == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableCliffSensor.Size;
        break;
      case Tag.EnableStopOnCliff:
        if (EnableStopOnCliff == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableStopOnCliff.Size;
        break;
      case Tag.StopAllMotors:
        if (StopAllMotors == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += StopAllMotors.Size;
        break;
      case Tag.ControllerGains:
        if (ControllerGains == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ControllerGains.Size;
        break;
      case Tag.RollActionParams:
        if (RollActionParams == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RollActionParams.Size;
        break;
      case Tag.SetMotionModelParams:
        if (SetMotionModelParams == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetMotionModelParams.Size;
        break;
      case Tag.SetRobotVolume:
        if (SetRobotVolume == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetRobotVolume.Size;
        break;
      case Tag.ForceDelocalizeRobot:
        if (ForceDelocalizeRobot == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ForceDelocalizeRobot.Size;
        break;
      case Tag.CancelAction:
        if (CancelAction == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CancelAction.Size;
        break;
      case Tag.CancelActionByIdTag:
        if (CancelActionByIdTag == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += CancelActionByIdTag.Size;
        break;
      case Tag.QueueSingleAction:
        if (QueueSingleAction == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += QueueSingleAction.Size;
        break;
      case Tag.QueueCompoundAction:
        if (QueueCompoundAction == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += QueueCompoundAction.Size;
        break;
      case Tag.RedirectViz:
        if (RedirectViz == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RedirectViz.Size;
        break;
      case Tag.ImageRequest:
        if (ImageRequest == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ImageRequest.Size;
        break;
      case Tag.SaveImages:
        if (SaveImages == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SaveImages.Size;
        break;
      case Tag.EnableColorImages:
        if (EnableColorImages == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableColorImages.Size;
        break;
      case Tag.SaveRobotState:
        if (SaveRobotState == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SaveRobotState.Size;
        break;
      case Tag.EnableDisplay:
        if (EnableDisplay == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableDisplay.Size;
        break;
      case Tag.ExecuteTestPlan:
        if (ExecuteTestPlan == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ExecuteTestPlan.Size;
        break;
      case Tag.SelectNextObject:
        if (SelectNextObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SelectNextObject.Size;
        break;
      case Tag.SetRobotCarryingObject:
        if (SetRobotCarryingObject == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetRobotCarryingObject.Size;
        break;
      case Tag.DeleteAllCustomObjects:
        if (DeleteAllCustomObjects == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DeleteAllCustomObjects.Size;
        break;
      case Tag.VisionWhileMoving:
        if (VisionWhileMoving == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisionWhileMoving.Size;
        break;
      case Tag.VisionRunMode:
        if (VisionRunMode == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisionRunMode.Size;
        break;
      case Tag.SaveFaceAlbumToFile:
        if (SaveFaceAlbumToFile == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SaveFaceAlbumToFile.Size;
        break;
      case Tag.LoadFaceAlbumFromFile:
        if (LoadFaceAlbumFromFile == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += LoadFaceAlbumFromFile.Size;
        break;
      case Tag.SetCameraCaptureFormat:
        if (SetCameraCaptureFormat == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetCameraCaptureFormat.Size;
        break;
      case Tag.SetMemoryMapRenderEnabled:
        if (SetMemoryMapRenderEnabled == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetMemoryMapRenderEnabled.Size;
        break;
      case Tag.FakeTriggerWordDetected:
        if (FakeTriggerWordDetected == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += FakeTriggerWordDetected.Size;
        break;
      case Tag.FakeCloudIntent:
        if (FakeCloudIntent == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += FakeCloudIntent.Size;
        break;
      case Tag.FakeUserIntent:
        if (FakeUserIntent == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += FakeUserIntent.Size;
        break;
      case Tag.ExecuteBehaviorByID:
        if (ExecuteBehaviorByID == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ExecuteBehaviorByID.Size;
        break;
      case Tag.SetLiftLoadTestAsActivatable:
        if (SetLiftLoadTestAsActivatable == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetLiftLoadTestAsActivatable.Size;
        break;
      case Tag.AbortPath:
        if (AbortPath == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AbortPath.Size;
        break;
      case Tag.AbortAll:
        if (AbortAll == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += AbortAll.Size;
        break;
      case Tag.StartTestMode:
        if (StartTestMode == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += StartTestMode.Size;
        break;
      case Tag.DrawPoseMarker:
        if (DrawPoseMarker == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DrawPoseMarker.Size;
        break;
      case Tag.ErasePoseMarker:
        if (ErasePoseMarker == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ErasePoseMarker.Size;
        break;
      case Tag.VisualizeQuad:
        if (VisualizeQuad == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += VisualizeQuad.Size;
        break;
      case Tag.EraseQuad:
        if (EraseQuad == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EraseQuad.Size;
        break;
      case Tag.ReadAnimationFile:
        if (ReadAnimationFile == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ReadAnimationFile.Size;
        break;
      case Tag.RequestAvailableAnimationGroups:
        if (RequestAvailableAnimationGroups == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RequestAvailableAnimationGroups.Size;
        break;
      case Tag.PushDrivingAnimations:
        if (PushDrivingAnimations == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PushDrivingAnimations.Size;
        break;
      case Tag.RemoveDrivingAnimations:
        if (RemoveDrivingAnimations == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RemoveDrivingAnimations.Size;
        break;
      case Tag.DisplayProceduralFace:
        if (DisplayProceduralFace == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DisplayProceduralFace.Size;
        break;
      case Tag.SetFaceHue:
        if (SetFaceHue == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetFaceHue.Size;
        break;
      case Tag.DisplayFaceImageBinaryChunk:
        if (DisplayFaceImageBinaryChunk == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DisplayFaceImageBinaryChunk.Size;
        break;
      case Tag.SetActiveObjectLEDs:
        if (SetActiveObjectLEDs == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetActiveObjectLEDs.Size;
        break;
      case Tag.SetAllActiveObjectLEDs:
        if (SetAllActiveObjectLEDs == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetAllActiveObjectLEDs.Size;
        break;
      case Tag.SetBackpackLEDs:
        if (SetBackpackLEDs == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetBackpackLEDs.Size;
        break;
      case Tag.EnableLightStates:
        if (EnableLightStates == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += EnableLightStates.Size;
        break;
      case Tag.PlayCubeAnim:
        if (PlayCubeAnim == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += PlayCubeAnim.Size;
        break;
      case Tag.StopCubeAnim:
        if (StopCubeAnim == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += StopCubeAnim.Size;
        break;
      case Tag.SetOnboardingStage:
        if (SetOnboardingStage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetOnboardingStage.Size;
        break;
      case Tag.MoodMessage:
        if (MoodMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += MoodMessage.Size;
        break;
      case Tag.SetDebugConsoleVarMessage:
        if (SetDebugConsoleVarMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetDebugConsoleVarMessage.Size;
        break;
      case Tag.SetAnimDebugConsoleVarMessage:
        if (SetAnimDebugConsoleVarMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetAnimDebugConsoleVarMessage.Size;
        break;
      case Tag.RunDebugConsoleFuncMessage:
        if (RunDebugConsoleFuncMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RunDebugConsoleFuncMessage.Size;
        break;
      case Tag.RunAnimDebugConsoleFuncMessage:
        if (RunAnimDebugConsoleFuncMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RunAnimDebugConsoleFuncMessage.Size;
        break;
      case Tag.GetDebugConsoleVarMessage:
        if (GetDebugConsoleVarMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GetDebugConsoleVarMessage.Size;
        break;
      case Tag.GetAllDebugConsoleVarMessage:
        if (GetAllDebugConsoleVarMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GetAllDebugConsoleVarMessage.Size;
        break;
      case Tag.GetJsonDasLogsMessage:
        if (GetJsonDasLogsMessage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += GetJsonDasLogsMessage.Size;
        break;
      case Tag.SetEnableSpeedChooser:
        if (SetEnableSpeedChooser == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetEnableSpeedChooser.Size;
        break;
      case Tag.LogRawCliffData:
        if (LogRawCliffData == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += LogRawCliffData.Size;
        break;
      case Tag.LogRawProxData:
        if (LogRawProxData == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += LogRawProxData.Size;
        break;
      case Tag.ConnectToCube:
        if (ConnectToCube == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ConnectToCube.Size;
        break;
      case Tag.DisconnectFromCube:
        if (DisconnectFromCube == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += DisconnectFromCube.Size;
        break;
      case Tag.ForgetPreferredCube:
        if (ForgetPreferredCube == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ForgetPreferredCube.Size;
        break;
      case Tag.SetPreferredCube:
        if (SetPreferredCube == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetPreferredCube.Size;
        break;
      case Tag.SendAvailableObjects:
        if (SendAvailableObjects == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SendAvailableObjects.Size;
        break;
      case Tag.SaveCalibrationImage:
        if (SaveCalibrationImage == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SaveCalibrationImage.Size;
        break;
      case Tag.ClearCalibrationImages:
        if (ClearCalibrationImages == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ClearCalibrationImages.Size;
        break;
      case Tag.ComputeCameraCalibration:
        if (ComputeCameraCalibration == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += ComputeCameraCalibration.Size;
        break;
      case Tag.TransferFile:
        if (TransferFile == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += TransferFile.Size;
        break;
      case Tag.SetCameraSettings:
        if (SetCameraSettings == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += SetCameraSettings.Size;
        break;
      case Tag.RequestRobotSettings:
        if (RequestRobotSettings == null) {
          throw new System.InvalidOperationException("Messages may not have null members.");
        }
        result += RequestRobotSettings.Size;
        break;
      default:
        // Just tag size
        break;
      }
      return result;
    }
  }

  public static bool operator ==(MessageGameToEngine a, MessageGameToEngine b)
  {
    if (System.Object.ReferenceEquals(a, null))
    {
      return System.Object.ReferenceEquals(b, null);
    }

    return a.Equals(b);
  }

  public static bool operator !=(MessageGameToEngine a, MessageGameToEngine b)
  {
    return !(a == b);
  }

  public override bool Equals(System.Object obj)
  {
    return this.Equals(obj as MessageGameToEngine);
  }

  public bool Equals(MessageGameToEngine p)
  {
    if (System.Object.ReferenceEquals(p, null))
    {
      return false;
    }

    return (_tag == p._tag && _state.Equals(p._state));
  }

  public override int GetHashCode()
  {
    unchecked
    {
      int hash = 17;
      hash = hash * 23 + this._tag.GetHashCode();
      hash = hash * 23 + this._state.GetHashCode();
      return hash;
    }
  }
}

} // namespace ExternalInterface

} // namespace Vector

} // namespace Anki