// Autogenerated C++ message buffer code.
// Source: clad/externalInterface/messageExternalComms.clad
// Full command line: victor-clad/tools/message-buffers/emitters/CPP_emitter.py --output-union-helper-constructors -C sdk -I victor-clad/clad/sdk -o generated/clad clad/externalInterface/messageExternalComms.clad

#include "messageExternalComms.h"

namespace Anki {

namespace Vector {

namespace ExternalComms {

const char* EnumToString(const RtsMode m)
{
  switch(m) {
    case RtsMode::RAW:
      return "RAW";
    case RtsMode::CLAD:
      return "CLAD";
    case RtsMode::CLAD_ENCRYPTED:
      return "CLAD_ENCRYPTED";
    default: return nullptr;
  }
  return nullptr;
}

const char* RtsModeVersionHashStr = "60727560e08ec14a1346383480cf9222";

const uint8_t RtsModeVersionHash[16] = { 
    0x60, 0x72, 0x75, 0x60, 0xe0, 0x8e, 0xc1, 0x4a, 0x13, 0x46, 0x38, 0x34, 0x80, 0xcf, 0x92, 0x22 
};

const char* EnumToString(const RtsConnType m)
{
  switch(m) {
    case RtsConnType::FirstTimePair:
      return "FirstTimePair";
    case RtsConnType::Reconnection:
      return "Reconnection";
    default: return nullptr;
  }
  return nullptr;
}

const char* RtsConnTypeVersionHashStr = "8b45413b6963f40639e340d8652bbf0c";

const uint8_t RtsConnTypeVersionHash[16] = { 
    0x8b, 0x45, 0x41, 0x3b, 0x69, 0x63, 0xf4, 0x6, 0x39, 0xe3, 0x40, 0xd8, 0x65, 0x2b, 0xbf, 0xc 
};

const char* EnumToString(const RtsResponseCode m)
{
  switch(m) {
    case RtsResponseCode::NotCloudAuthorized:
      return "NotCloudAuthorized";
    default: return nullptr;
  }
  return nullptr;
}

const char* RtsResponseCodeVersionHashStr = "d8b9cc44b8287568ef1a3a1d2f6da965";

const uint8_t RtsResponseCodeVersionHash[16] = { 
    0xd8, 0xb9, 0xcc, 0x44, 0xb8, 0x28, 0x75, 0x68, 0xef, 0x1a, 0x3a, 0x1d, 0x2f, 0x6d, 0xa9, 0x65 
};

const char* EnumToString(const RtsCloudStatus m)
{
  switch(m) {
    case RtsCloudStatus::UnknownError:
      return "UnknownError";
    case RtsCloudStatus::ConnectionError:
      return "ConnectionError";
    case RtsCloudStatus::WrongAccount:
      return "WrongAccount";
    case RtsCloudStatus::InvalidSessionToken:
      return "InvalidSessionToken";
    case RtsCloudStatus::AuthorizedAsPrimary:
      return "AuthorizedAsPrimary";
    case RtsCloudStatus::AuthorizedAsSecondary:
      return "AuthorizedAsSecondary";
    case RtsCloudStatus::Reauthorized:
      return "Reauthorized";
    default: return nullptr;
  }
  return nullptr;
}

const char* RtsCloudStatusVersionHashStr = "971e60057a96b9080eaac9281db9b645";

const uint8_t RtsCloudStatusVersionHash[16] = { 
    0x97, 0x1e, 0x60, 0x5, 0x7a, 0x96, 0xb9, 0x8, 0xe, 0xaa, 0xc9, 0x28, 0x1d, 0xb9, 0xb6, 0x45 
};

// MESSAGE RtsWifiScanResult

RtsWifiScanResult::RtsWifiScanResult(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResult::RtsWifiScanResult(const uint8_t* buff, size_t len)
: RtsWifiScanResult::RtsWifiScanResult({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResult::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResult::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->authType);
  buffer.Write(this->signalStrength);
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResult::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResult::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->authType);
  buffer.Read(this->signalStrength);
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResult::Size() const
{
  size_t result = 0;
  // authType
  result += 1; // uint_8
  // signalStrength
  result += 1; // uint_8
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  return result;
}

bool RtsWifiScanResult::operator==(const RtsWifiScanResult& other) const
{
  return (this->authType == other.authType &&
    this->signalStrength == other.signalStrength &&
    this->wifiSsidHex == other.wifiSsidHex);
}

bool RtsWifiScanResult::operator!=(const RtsWifiScanResult& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResultVersionHashStr = "ca6c71a0b6d0276eb4c2caee19f2b009";

const uint8_t RtsWifiScanResultVersionHash[16] = { 
    0xca, 0x6c, 0x71, 0xa0, 0xb6, 0xd0, 0x27, 0x6e, 0xb4, 0xc2, 0xca, 0xee, 0x19, 0xf2, 0xb0, 0x9 
};

// MESSAGE RtsWifiScanResult_2

RtsWifiScanResult_2::RtsWifiScanResult_2(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResult_2::RtsWifiScanResult_2(const uint8_t* buff, size_t len)
: RtsWifiScanResult_2::RtsWifiScanResult_2({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResult_2::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResult_2::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->authType);
  buffer.Write(this->signalStrength);
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->hidden);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResult_2::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResult_2::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->authType);
  buffer.Read(this->signalStrength);
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->hidden);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResult_2::Size() const
{
  size_t result = 0;
  // authType
  result += 1; // uint_8
  // signalStrength
  result += 1; // uint_8
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // hidden
  result += 1; // bool
  return result;
}

bool RtsWifiScanResult_2::operator==(const RtsWifiScanResult_2& other) const
{
  return (this->authType == other.authType &&
    this->signalStrength == other.signalStrength &&
    this->wifiSsidHex == other.wifiSsidHex &&
    this->hidden == other.hidden);
}

bool RtsWifiScanResult_2::operator!=(const RtsWifiScanResult_2& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResult_2VersionHashStr = "f4e18ee8afb30753a7148a500a1070a5";

const uint8_t RtsWifiScanResult_2VersionHash[16] = { 
    0xf4, 0xe1, 0x8e, 0xe8, 0xaf, 0xb3, 0x7, 0x53, 0xa7, 0x14, 0x8a, 0x50, 0xa, 0x10, 0x70, 0xa5 
};

// MESSAGE RtsWifiScanResult_3

RtsWifiScanResult_3::RtsWifiScanResult_3(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResult_3::RtsWifiScanResult_3(const uint8_t* buff, size_t len)
: RtsWifiScanResult_3::RtsWifiScanResult_3({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResult_3::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResult_3::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->authType);
  buffer.Write(this->signalStrength);
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->hidden);
  buffer.Write(this->provisioned);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResult_3::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResult_3::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->authType);
  buffer.Read(this->signalStrength);
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->hidden);
  buffer.Read(this->provisioned);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResult_3::Size() const
{
  size_t result = 0;
  // authType
  result += 1; // uint_8
  // signalStrength
  result += 1; // uint_8
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // hidden
  result += 1; // bool
  // provisioned
  result += 1; // bool
  return result;
}

bool RtsWifiScanResult_3::operator==(const RtsWifiScanResult_3& other) const
{
  return (this->authType == other.authType &&
    this->signalStrength == other.signalStrength &&
    this->wifiSsidHex == other.wifiSsidHex &&
    this->hidden == other.hidden &&
    this->provisioned == other.provisioned);
}

bool RtsWifiScanResult_3::operator!=(const RtsWifiScanResult_3& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResult_3VersionHashStr = "212d69873d1a4cb0ff6759ba41ce663c";

const uint8_t RtsWifiScanResult_3VersionHash[16] = { 
    0x21, 0x2d, 0x69, 0x87, 0x3d, 0x1a, 0x4c, 0xb0, 0xff, 0x67, 0x59, 0xba, 0x41, 0xce, 0x66, 0x3c 
};

// MESSAGE RtsConnRequest

RtsConnRequest::RtsConnRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsConnRequest::RtsConnRequest(const uint8_t* buff, size_t len)
: RtsConnRequest::RtsConnRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsConnRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WriteFArray<uint8_t, 32>(this->publicKey);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsConnRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadFArray<uint8_t, 32>(this->publicKey);
  return buffer.GetBytesRead();
}

size_t RtsConnRequest::Size() const
{
  size_t result = 0;
  // publicKey
  result += 1 * 32; // uint_8 * 32
  return result;
}

bool RtsConnRequest::operator==(const RtsConnRequest& other) const
{
  return (this->publicKey == other.publicKey);
}

bool RtsConnRequest::operator!=(const RtsConnRequest& other) const
{
  return !(operator==(other));
}


const char* RtsConnRequestVersionHashStr = "ff06529f81ae651acd93857014b358f5";

const uint8_t RtsConnRequestVersionHash[16] = { 
    0xff, 0x6, 0x52, 0x9f, 0x81, 0xae, 0x65, 0x1a, 0xcd, 0x93, 0x85, 0x70, 0x14, 0xb3, 0x58, 0xf5 
};

// MESSAGE RtsConnResponse

RtsConnResponse::RtsConnResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsConnResponse::RtsConnResponse(const uint8_t* buff, size_t len)
: RtsConnResponse::RtsConnResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsConnResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->connectionType);
  buffer.WriteFArray<uint8_t, 32>(this->publicKey);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsConnResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->connectionType);
  buffer.ReadFArray<uint8_t, 32>(this->publicKey);
  return buffer.GetBytesRead();
}

size_t RtsConnResponse::Size() const
{
  size_t result = 0;
  // connectionType
  result += 1; // RtsConnType
  // publicKey
  result += 1 * 32; // uint_8 * 32
  return result;
}

bool RtsConnResponse::operator==(const RtsConnResponse& other) const
{
  return (this->connectionType == other.connectionType &&
    this->publicKey == other.publicKey);
}

bool RtsConnResponse::operator!=(const RtsConnResponse& other) const
{
  return !(operator==(other));
}


const char* RtsConnResponseVersionHashStr = "a87800ef74ba59cc1ab5f2edafe365be";

const uint8_t RtsConnResponseVersionHash[16] = { 
    0xa8, 0x78, 0x0, 0xef, 0x74, 0xba, 0x59, 0xcc, 0x1a, 0xb5, 0xf2, 0xed, 0xaf, 0xe3, 0x65, 0xbe 
};

// MESSAGE RtsNonceMessage

RtsNonceMessage::RtsNonceMessage(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsNonceMessage::RtsNonceMessage(const uint8_t* buff, size_t len)
: RtsNonceMessage::RtsNonceMessage({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsNonceMessage::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsNonceMessage::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WriteFArray<uint8_t, 24>(this->toRobotNonce);
  buffer.WriteFArray<uint8_t, 24>(this->toDeviceNonce);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsNonceMessage::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsNonceMessage::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadFArray<uint8_t, 24>(this->toRobotNonce);
  buffer.ReadFArray<uint8_t, 24>(this->toDeviceNonce);
  return buffer.GetBytesRead();
}

size_t RtsNonceMessage::Size() const
{
  size_t result = 0;
  // toRobotNonce
  result += 1 * 24; // uint_8 * 24
  // toDeviceNonce
  result += 1 * 24; // uint_8 * 24
  return result;
}

bool RtsNonceMessage::operator==(const RtsNonceMessage& other) const
{
  return (this->toRobotNonce == other.toRobotNonce &&
    this->toDeviceNonce == other.toDeviceNonce);
}

bool RtsNonceMessage::operator!=(const RtsNonceMessage& other) const
{
  return !(operator==(other));
}


const char* RtsNonceMessageVersionHashStr = "ea22ba0580cec176e710fd8fa089e7ea";

const uint8_t RtsNonceMessageVersionHash[16] = { 
    0xea, 0x22, 0xba, 0x5, 0x80, 0xce, 0xc1, 0x76, 0xe7, 0x10, 0xfd, 0x8f, 0xa0, 0x89, 0xe7, 0xea 
};

// MESSAGE RtsAck

RtsAck::RtsAck(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsAck::RtsAck(const uint8_t* buff, size_t len)
: RtsAck::RtsAck({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsAck::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsAck::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->rtsConnectionTag);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsAck::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsAck::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->rtsConnectionTag);
  return buffer.GetBytesRead();
}

size_t RtsAck::Size() const
{
  size_t result = 0;
  // rtsConnectionTag
  result += 1; // uint_8
  return result;
}

bool RtsAck::operator==(const RtsAck& other) const
{
  return (this->rtsConnectionTag == other.rtsConnectionTag);
}

bool RtsAck::operator!=(const RtsAck& other) const
{
  return !(operator==(other));
}


const char* RtsAckVersionHashStr = "59a4cbeb3e6ce69c9aa9cdc838cef4ee";

const uint8_t RtsAckVersionHash[16] = { 
    0x59, 0xa4, 0xcb, 0xeb, 0x3e, 0x6c, 0xe6, 0x9c, 0x9a, 0xa9, 0xcd, 0xc8, 0x38, 0xce, 0xf4, 0xee 
};

// MESSAGE RtsChallengeMessage

RtsChallengeMessage::RtsChallengeMessage(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsChallengeMessage::RtsChallengeMessage(const uint8_t* buff, size_t len)
: RtsChallengeMessage::RtsChallengeMessage({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsChallengeMessage::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsChallengeMessage::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->number);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsChallengeMessage::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsChallengeMessage::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->number);
  return buffer.GetBytesRead();
}

size_t RtsChallengeMessage::Size() const
{
  size_t result = 0;
  // number
  result += 4; // uint_32
  return result;
}

bool RtsChallengeMessage::operator==(const RtsChallengeMessage& other) const
{
  return (this->number == other.number);
}

bool RtsChallengeMessage::operator!=(const RtsChallengeMessage& other) const
{
  return !(operator==(other));
}


const char* RtsChallengeMessageVersionHashStr = "14416612c69b3f9d46835cc35ced9d72";

const uint8_t RtsChallengeMessageVersionHash[16] = { 
    0x14, 0x41, 0x66, 0x12, 0xc6, 0x9b, 0x3f, 0x9d, 0x46, 0x83, 0x5c, 0xc3, 0x5c, 0xed, 0x9d, 0x72 
};

// MESSAGE RtsChallengeSuccessMessage

RtsChallengeSuccessMessage::RtsChallengeSuccessMessage(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsChallengeSuccessMessage::RtsChallengeSuccessMessage(const uint8_t* buff, size_t len)
: RtsChallengeSuccessMessage::RtsChallengeSuccessMessage({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsChallengeSuccessMessage::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsChallengeSuccessMessage::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsChallengeSuccessMessage::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsChallengeSuccessMessage::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsChallengeSuccessMessage::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsChallengeSuccessMessage::operator==(const RtsChallengeSuccessMessage& other) const
{
return true;
}

bool RtsChallengeSuccessMessage::operator!=(const RtsChallengeSuccessMessage& other) const
{
  return !(operator==(other));
}


const char* RtsChallengeSuccessMessageVersionHashStr = "e668a2b6dce93f0fdfdc2495d13139f8";

const uint8_t RtsChallengeSuccessMessageVersionHash[16] = { 
    0xe6, 0x68, 0xa2, 0xb6, 0xdc, 0xe9, 0x3f, 0xf, 0xdf, 0xdc, 0x24, 0x95, 0xd1, 0x31, 0x39, 0xf8 
};

// MESSAGE RtsWifiForgetRequest

RtsWifiForgetRequest::RtsWifiForgetRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiForgetRequest::RtsWifiForgetRequest(const uint8_t* buff, size_t len)
: RtsWifiForgetRequest::RtsWifiForgetRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiForgetRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiForgetRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->deleteAll);
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiForgetRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiForgetRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->deleteAll);
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  return buffer.GetBytesRead();
}

size_t RtsWifiForgetRequest::Size() const
{
  size_t result = 0;
  // deleteAll
  result += 1; // bool
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  return result;
}

bool RtsWifiForgetRequest::operator==(const RtsWifiForgetRequest& other) const
{
  return (this->deleteAll == other.deleteAll &&
    this->wifiSsidHex == other.wifiSsidHex);
}

bool RtsWifiForgetRequest::operator!=(const RtsWifiForgetRequest& other) const
{
  return !(operator==(other));
}


const char* RtsWifiForgetRequestVersionHashStr = "9fd6f373d96de48b7ff51babc3478ac5";

const uint8_t RtsWifiForgetRequestVersionHash[16] = { 
    0x9f, 0xd6, 0xf3, 0x73, 0xd9, 0x6d, 0xe4, 0x8b, 0x7f, 0xf5, 0x1b, 0xab, 0xc3, 0x47, 0x8a, 0xc5 
};

// MESSAGE RtsWifiForgetResponse

RtsWifiForgetResponse::RtsWifiForgetResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiForgetResponse::RtsWifiForgetResponse(const uint8_t* buff, size_t len)
: RtsWifiForgetResponse::RtsWifiForgetResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiForgetResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiForgetResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->didDelete);
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiForgetResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiForgetResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->didDelete);
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  return buffer.GetBytesRead();
}

size_t RtsWifiForgetResponse::Size() const
{
  size_t result = 0;
  // didDelete
  result += 1; // bool
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  return result;
}

bool RtsWifiForgetResponse::operator==(const RtsWifiForgetResponse& other) const
{
  return (this->didDelete == other.didDelete &&
    this->wifiSsidHex == other.wifiSsidHex);
}

bool RtsWifiForgetResponse::operator!=(const RtsWifiForgetResponse& other) const
{
  return !(operator==(other));
}


const char* RtsWifiForgetResponseVersionHashStr = "155f09a2552a6653550984e02d73d02e";

const uint8_t RtsWifiForgetResponseVersionHash[16] = { 
    0x15, 0x5f, 0x9, 0xa2, 0x55, 0x2a, 0x66, 0x53, 0x55, 0x9, 0x84, 0xe0, 0x2d, 0x73, 0xd0, 0x2e 
};

// MESSAGE RtsWifiConnectRequest

RtsWifiConnectRequest::RtsWifiConnectRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiConnectRequest::RtsWifiConnectRequest(const uint8_t* buff, size_t len)
: RtsWifiConnectRequest::RtsWifiConnectRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiConnectRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiConnectRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.WritePString<uint8_t>(this->password);
  buffer.Write(this->timeout);
  buffer.Write(this->authType);
  buffer.Write(this->hidden);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiConnectRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiConnectRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.ReadPString<uint8_t>(this->password);
  buffer.Read(this->timeout);
  buffer.Read(this->authType);
  buffer.Read(this->hidden);
  return buffer.GetBytesRead();
}

size_t RtsWifiConnectRequest::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // password
  result += 1; // uint_8 (string length)
  result += this->password.length(); // uint_8
  // timeout
  result += 1; // uint_8
  // authType
  result += 1; // uint_8
  // hidden
  result += 1; // bool
  return result;
}

bool RtsWifiConnectRequest::operator==(const RtsWifiConnectRequest& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->password == other.password &&
    this->timeout == other.timeout &&
    this->authType == other.authType &&
    this->hidden == other.hidden);
}

bool RtsWifiConnectRequest::operator!=(const RtsWifiConnectRequest& other) const
{
  return !(operator==(other));
}


const char* RtsWifiConnectRequestVersionHashStr = "47fe754b56f91dce0270badb7c562a5c";

const uint8_t RtsWifiConnectRequestVersionHash[16] = { 
    0x47, 0xfe, 0x75, 0x4b, 0x56, 0xf9, 0x1d, 0xce, 0x2, 0x70, 0xba, 0xdb, 0x7c, 0x56, 0x2a, 0x5c 
};

// MESSAGE RtsWifiConnectResponse

RtsWifiConnectResponse::RtsWifiConnectResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiConnectResponse::RtsWifiConnectResponse(const uint8_t* buff, size_t len)
: RtsWifiConnectResponse::RtsWifiConnectResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiConnectResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiConnectResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiConnectResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiConnectResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  return buffer.GetBytesRead();
}

size_t RtsWifiConnectResponse::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  return result;
}

bool RtsWifiConnectResponse::operator==(const RtsWifiConnectResponse& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState);
}

bool RtsWifiConnectResponse::operator!=(const RtsWifiConnectResponse& other) const
{
  return !(operator==(other));
}


const char* RtsWifiConnectResponseVersionHashStr = "082fd7c04cd3d02f65f2262db8f5919b";

const uint8_t RtsWifiConnectResponseVersionHash[16] = { 
    0x8, 0x2f, 0xd7, 0xc0, 0x4c, 0xd3, 0xd0, 0x2f, 0x65, 0xf2, 0x26, 0x2d, 0xb8, 0xf5, 0x91, 0x9b 
};

// MESSAGE RtsWifiConnectResponse_3

RtsWifiConnectResponse_3::RtsWifiConnectResponse_3(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiConnectResponse_3::RtsWifiConnectResponse_3(const uint8_t* buff, size_t len)
: RtsWifiConnectResponse_3::RtsWifiConnectResponse_3({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiConnectResponse_3::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiConnectResponse_3::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->connectResult);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiConnectResponse_3::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiConnectResponse_3::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->connectResult);
  return buffer.GetBytesRead();
}

size_t RtsWifiConnectResponse_3::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // connectResult
  result += 1; // uint_8
  return result;
}

bool RtsWifiConnectResponse_3::operator==(const RtsWifiConnectResponse_3& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->connectResult == other.connectResult);
}

bool RtsWifiConnectResponse_3::operator!=(const RtsWifiConnectResponse_3& other) const
{
  return !(operator==(other));
}


const char* RtsWifiConnectResponse_3VersionHashStr = "bedb19cc2f803794dc0ce5dc82dd1600";

const uint8_t RtsWifiConnectResponse_3VersionHash[16] = { 
    0xbe, 0xdb, 0x19, 0xcc, 0x2f, 0x80, 0x37, 0x94, 0xdc, 0xc, 0xe5, 0xdc, 0x82, 0xdd, 0x16, 0x0 
};

// MESSAGE RtsWifiIpRequest

RtsWifiIpRequest::RtsWifiIpRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiIpRequest::RtsWifiIpRequest(const uint8_t* buff, size_t len)
: RtsWifiIpRequest::RtsWifiIpRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiIpRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiIpRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiIpRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiIpRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsWifiIpRequest::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsWifiIpRequest::operator==(const RtsWifiIpRequest& other) const
{
return true;
}

bool RtsWifiIpRequest::operator!=(const RtsWifiIpRequest& other) const
{
  return !(operator==(other));
}


const char* RtsWifiIpRequestVersionHashStr = "260b5113893e56678c0abf2fd3e04ac7";

const uint8_t RtsWifiIpRequestVersionHash[16] = { 
    0x26, 0xb, 0x51, 0x13, 0x89, 0x3e, 0x56, 0x67, 0x8c, 0xa, 0xbf, 0x2f, 0xd3, 0xe0, 0x4a, 0xc7 
};

// MESSAGE RtsWifiIpResponse

RtsWifiIpResponse::RtsWifiIpResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiIpResponse::RtsWifiIpResponse(const uint8_t* buff, size_t len)
: RtsWifiIpResponse::RtsWifiIpResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiIpResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiIpResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->hasIpV4);
  buffer.Write(this->hasIpV6);
  buffer.WriteFArray<uint8_t, 4>(this->ipV4);
  buffer.WriteFArray<uint8_t, 16>(this->ipV6);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiIpResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiIpResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->hasIpV4);
  buffer.Read(this->hasIpV6);
  buffer.ReadFArray<uint8_t, 4>(this->ipV4);
  buffer.ReadFArray<uint8_t, 16>(this->ipV6);
  return buffer.GetBytesRead();
}

size_t RtsWifiIpResponse::Size() const
{
  size_t result = 0;
  // hasIpV4
  result += 1; // uint_8
  // hasIpV6
  result += 1; // uint_8
  // ipV4
  result += 1 * 4; // uint_8 * 4
  // ipV6
  result += 1 * 16; // uint_8 * 16
  return result;
}

bool RtsWifiIpResponse::operator==(const RtsWifiIpResponse& other) const
{
  return (this->hasIpV4 == other.hasIpV4 &&
    this->hasIpV6 == other.hasIpV6 &&
    this->ipV4 == other.ipV4 &&
    this->ipV6 == other.ipV6);
}

bool RtsWifiIpResponse::operator!=(const RtsWifiIpResponse& other) const
{
  return !(operator==(other));
}


const char* RtsWifiIpResponseVersionHashStr = "a86086af8ee93d88bac4c9896b3c5477";

const uint8_t RtsWifiIpResponseVersionHash[16] = { 
    0xa8, 0x60, 0x86, 0xaf, 0x8e, 0xe9, 0x3d, 0x88, 0xba, 0xc4, 0xc9, 0x89, 0x6b, 0x3c, 0x54, 0x77 
};

// MESSAGE RtsStatusRequest

RtsStatusRequest::RtsStatusRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusRequest::RtsStatusRequest(const uint8_t* buff, size_t len)
: RtsStatusRequest::RtsStatusRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsStatusRequest::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsStatusRequest::operator==(const RtsStatusRequest& other) const
{
return true;
}

bool RtsStatusRequest::operator!=(const RtsStatusRequest& other) const
{
  return !(operator==(other));
}


const char* RtsStatusRequestVersionHashStr = "6a2d2d09edf31c79d9fe2e960ed347fa";

const uint8_t RtsStatusRequestVersionHash[16] = { 
    0x6a, 0x2d, 0x2d, 0x9, 0xed, 0xf3, 0x1c, 0x79, 0xd9, 0xfe, 0x2e, 0x96, 0xe, 0xd3, 0x47, 0xfa 
};

// MESSAGE RtsStatusResponse

RtsStatusResponse::RtsStatusResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusResponse::RtsStatusResponse(const uint8_t* buff, size_t len)
: RtsStatusResponse::RtsStatusResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->accessPoint);
  buffer.Write(this->bleState);
  buffer.Write(this->batteryState);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->accessPoint);
  buffer.Read(this->bleState);
  buffer.Read(this->batteryState);
  return buffer.GetBytesRead();
}

size_t RtsStatusResponse::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // accessPoint
  result += 1; // bool
  // bleState
  result += 1; // uint_8
  // batteryState
  result += 1; // uint_8
  return result;
}

bool RtsStatusResponse::operator==(const RtsStatusResponse& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->accessPoint == other.accessPoint &&
    this->bleState == other.bleState &&
    this->batteryState == other.batteryState);
}

bool RtsStatusResponse::operator!=(const RtsStatusResponse& other) const
{
  return !(operator==(other));
}


const char* RtsStatusResponseVersionHashStr = "7f8d5ead923b52435332b8098e49ebd1";

const uint8_t RtsStatusResponseVersionHash[16] = { 
    0x7f, 0x8d, 0x5e, 0xad, 0x92, 0x3b, 0x52, 0x43, 0x53, 0x32, 0xb8, 0x9, 0x8e, 0x49, 0xeb, 0xd1 
};

// MESSAGE RtsStatusResponse_2

RtsStatusResponse_2::RtsStatusResponse_2(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusResponse_2::RtsStatusResponse_2(const uint8_t* buff, size_t len)
: RtsStatusResponse_2::RtsStatusResponse_2({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusResponse_2::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusResponse_2::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->accessPoint);
  buffer.Write(this->bleState);
  buffer.Write(this->batteryState);
  buffer.WritePString<uint8_t>(this->version);
  buffer.Write(this->otaInProgress);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusResponse_2::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusResponse_2::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->accessPoint);
  buffer.Read(this->bleState);
  buffer.Read(this->batteryState);
  buffer.ReadPString<uint8_t>(this->version);
  buffer.Read(this->otaInProgress);
  return buffer.GetBytesRead();
}

size_t RtsStatusResponse_2::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // accessPoint
  result += 1; // bool
  // bleState
  result += 1; // uint_8
  // batteryState
  result += 1; // uint_8
  // version
  result += 1; // uint_8 (string length)
  result += this->version.length(); // uint_8
  // otaInProgress
  result += 1; // bool
  return result;
}

bool RtsStatusResponse_2::operator==(const RtsStatusResponse_2& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->accessPoint == other.accessPoint &&
    this->bleState == other.bleState &&
    this->batteryState == other.batteryState &&
    this->version == other.version &&
    this->otaInProgress == other.otaInProgress);
}

bool RtsStatusResponse_2::operator!=(const RtsStatusResponse_2& other) const
{
  return !(operator==(other));
}


const char* RtsStatusResponse_2VersionHashStr = "c78dea3bc2590d0d6d2d8343482d2783";

const uint8_t RtsStatusResponse_2VersionHash[16] = { 
    0xc7, 0x8d, 0xea, 0x3b, 0xc2, 0x59, 0xd, 0xd, 0x6d, 0x2d, 0x83, 0x43, 0x48, 0x2d, 0x27, 0x83 
};

// MESSAGE RtsStatusResponse_3

RtsStatusResponse_3::RtsStatusResponse_3(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusResponse_3::RtsStatusResponse_3(const uint8_t* buff, size_t len)
: RtsStatusResponse_3::RtsStatusResponse_3({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusResponse_3::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusResponse_3::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->accessPoint);
  buffer.Write(this->bleState);
  buffer.Write(this->batteryState);
  buffer.WritePString<uint8_t>(this->version);
  buffer.Write(this->otaInProgress);
  buffer.Write(this->hasOwner);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusResponse_3::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusResponse_3::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->accessPoint);
  buffer.Read(this->bleState);
  buffer.Read(this->batteryState);
  buffer.ReadPString<uint8_t>(this->version);
  buffer.Read(this->otaInProgress);
  buffer.Read(this->hasOwner);
  return buffer.GetBytesRead();
}

size_t RtsStatusResponse_3::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // accessPoint
  result += 1; // bool
  // bleState
  result += 1; // uint_8
  // batteryState
  result += 1; // uint_8
  // version
  result += 1; // uint_8 (string length)
  result += this->version.length(); // uint_8
  // otaInProgress
  result += 1; // bool
  // hasOwner
  result += 1; // bool
  return result;
}

bool RtsStatusResponse_3::operator==(const RtsStatusResponse_3& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->accessPoint == other.accessPoint &&
    this->bleState == other.bleState &&
    this->batteryState == other.batteryState &&
    this->version == other.version &&
    this->otaInProgress == other.otaInProgress &&
    this->hasOwner == other.hasOwner);
}

bool RtsStatusResponse_3::operator!=(const RtsStatusResponse_3& other) const
{
  return !(operator==(other));
}


const char* RtsStatusResponse_3VersionHashStr = "9a6e0464dfc95ff93a373f02667bc05c";

const uint8_t RtsStatusResponse_3VersionHash[16] = { 
    0x9a, 0x6e, 0x4, 0x64, 0xdf, 0xc9, 0x5f, 0xf9, 0x3a, 0x37, 0x3f, 0x2, 0x66, 0x7b, 0xc0, 0x5c 
};

// MESSAGE RtsStatusResponse_4

RtsStatusResponse_4::RtsStatusResponse_4(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusResponse_4::RtsStatusResponse_4(const uint8_t* buff, size_t len)
: RtsStatusResponse_4::RtsStatusResponse_4({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusResponse_4::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusResponse_4::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->accessPoint);
  buffer.Write(this->bleState);
  buffer.Write(this->batteryState);
  buffer.WritePString<uint8_t>(this->version);
  buffer.WritePString<uint8_t>(this->esn);
  buffer.Write(this->otaInProgress);
  buffer.Write(this->hasOwner);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusResponse_4::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusResponse_4::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->accessPoint);
  buffer.Read(this->bleState);
  buffer.Read(this->batteryState);
  buffer.ReadPString<uint8_t>(this->version);
  buffer.ReadPString<uint8_t>(this->esn);
  buffer.Read(this->otaInProgress);
  buffer.Read(this->hasOwner);
  return buffer.GetBytesRead();
}

size_t RtsStatusResponse_4::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // accessPoint
  result += 1; // bool
  // bleState
  result += 1; // uint_8
  // batteryState
  result += 1; // uint_8
  // version
  result += 1; // uint_8 (string length)
  result += this->version.length(); // uint_8
  // esn
  result += 1; // uint_8 (string length)
  result += this->esn.length(); // uint_8
  // otaInProgress
  result += 1; // bool
  // hasOwner
  result += 1; // bool
  return result;
}

bool RtsStatusResponse_4::operator==(const RtsStatusResponse_4& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->accessPoint == other.accessPoint &&
    this->bleState == other.bleState &&
    this->batteryState == other.batteryState &&
    this->version == other.version &&
    this->esn == other.esn &&
    this->otaInProgress == other.otaInProgress &&
    this->hasOwner == other.hasOwner);
}

bool RtsStatusResponse_4::operator!=(const RtsStatusResponse_4& other) const
{
  return !(operator==(other));
}


const char* RtsStatusResponse_4VersionHashStr = "25f2f1d8ffb67d327b34101da683cdb4";

const uint8_t RtsStatusResponse_4VersionHash[16] = { 
    0x25, 0xf2, 0xf1, 0xd8, 0xff, 0xb6, 0x7d, 0x32, 0x7b, 0x34, 0x10, 0x1d, 0xa6, 0x83, 0xcd, 0xb4 
};

// MESSAGE RtsStatusResponse_5

RtsStatusResponse_5::RtsStatusResponse_5(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsStatusResponse_5::RtsStatusResponse_5(const uint8_t* buff, size_t len)
: RtsStatusResponse_5::RtsStatusResponse_5({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsStatusResponse_5::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsStatusResponse_5::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->wifiSsidHex);
  buffer.Write(this->wifiState);
  buffer.Write(this->accessPoint);
  buffer.Write(this->bleState);
  buffer.Write(this->batteryState);
  buffer.WritePString<uint8_t>(this->version);
  buffer.WritePString<uint8_t>(this->esn);
  buffer.Write(this->otaInProgress);
  buffer.Write(this->hasOwner);
  buffer.Write(this->isCloudAuthed);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsStatusResponse_5::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsStatusResponse_5::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->wifiSsidHex);
  buffer.Read(this->wifiState);
  buffer.Read(this->accessPoint);
  buffer.Read(this->bleState);
  buffer.Read(this->batteryState);
  buffer.ReadPString<uint8_t>(this->version);
  buffer.ReadPString<uint8_t>(this->esn);
  buffer.Read(this->otaInProgress);
  buffer.Read(this->hasOwner);
  buffer.Read(this->isCloudAuthed);
  return buffer.GetBytesRead();
}

size_t RtsStatusResponse_5::Size() const
{
  size_t result = 0;
  // wifiSsidHex
  result += 1; // uint_8 (string length)
  result += this->wifiSsidHex.length(); // uint_8
  // wifiState
  result += 1; // uint_8
  // accessPoint
  result += 1; // bool
  // bleState
  result += 1; // uint_8
  // batteryState
  result += 1; // uint_8
  // version
  result += 1; // uint_8 (string length)
  result += this->version.length(); // uint_8
  // esn
  result += 1; // uint_8 (string length)
  result += this->esn.length(); // uint_8
  // otaInProgress
  result += 1; // bool
  // hasOwner
  result += 1; // bool
  // isCloudAuthed
  result += 1; // bool
  return result;
}

bool RtsStatusResponse_5::operator==(const RtsStatusResponse_5& other) const
{
  return (this->wifiSsidHex == other.wifiSsidHex &&
    this->wifiState == other.wifiState &&
    this->accessPoint == other.accessPoint &&
    this->bleState == other.bleState &&
    this->batteryState == other.batteryState &&
    this->version == other.version &&
    this->esn == other.esn &&
    this->otaInProgress == other.otaInProgress &&
    this->hasOwner == other.hasOwner &&
    this->isCloudAuthed == other.isCloudAuthed);
}

bool RtsStatusResponse_5::operator!=(const RtsStatusResponse_5& other) const
{
  return !(operator==(other));
}


const char* RtsStatusResponse_5VersionHashStr = "3c43852ff42108343b883bb23a078e5c";

const uint8_t RtsStatusResponse_5VersionHash[16] = { 
    0x3c, 0x43, 0x85, 0x2f, 0xf4, 0x21, 0x8, 0x34, 0x3b, 0x88, 0x3b, 0xb2, 0x3a, 0x7, 0x8e, 0x5c 
};

// MESSAGE RtsWifiScanRequest

RtsWifiScanRequest::RtsWifiScanRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanRequest::RtsWifiScanRequest(const uint8_t* buff, size_t len)
: RtsWifiScanRequest::RtsWifiScanRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsWifiScanRequest::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsWifiScanRequest::operator==(const RtsWifiScanRequest& other) const
{
return true;
}

bool RtsWifiScanRequest::operator!=(const RtsWifiScanRequest& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanRequestVersionHashStr = "1375170c3e1e071f888962f7f5b65b19";

const uint8_t RtsWifiScanRequestVersionHash[16] = { 
    0x13, 0x75, 0x17, 0xc, 0x3e, 0x1e, 0x7, 0x1f, 0x88, 0x89, 0x62, 0xf7, 0xf5, 0xb6, 0x5b, 0x19 
};

// MESSAGE RtsWifiScanResponse

RtsWifiScanResponse::RtsWifiScanResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResponse::RtsWifiScanResponse(const uint8_t* buff, size_t len)
: RtsWifiScanResponse::RtsWifiScanResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->statusCode);
  buffer.Write(static_cast<uint8_t>(scanResult.size()));
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult& m : scanResult) {
    m.Pack(buffer);
  }
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->statusCode);
  buffer.ReadCompoundTypeVArray<Anki::Vector::ExternalComms::RtsWifiScanResult, uint8_t>(this->scanResult);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResponse::Size() const
{
  size_t result = 0;
  // statusCode
  result += 1; // uint_8
  // scanResult
  result += 1; // uint_8 (array length)
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult& m : this->scanResult) {
    result += m.Size();
  }
  return result;
}

bool RtsWifiScanResponse::operator==(const RtsWifiScanResponse& other) const
{
  return (this->statusCode == other.statusCode &&
    this->scanResult == other.scanResult);
}

bool RtsWifiScanResponse::operator!=(const RtsWifiScanResponse& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResponseVersionHashStr = "e4740280769c7f26bc97132fe6768790";

const uint8_t RtsWifiScanResponseVersionHash[16] = { 
    0xe4, 0x74, 0x2, 0x80, 0x76, 0x9c, 0x7f, 0x26, 0xbc, 0x97, 0x13, 0x2f, 0xe6, 0x76, 0x87, 0x90 
};

// MESSAGE RtsWifiScanResponse_2

RtsWifiScanResponse_2::RtsWifiScanResponse_2(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResponse_2::RtsWifiScanResponse_2(const uint8_t* buff, size_t len)
: RtsWifiScanResponse_2::RtsWifiScanResponse_2({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResponse_2::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResponse_2::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->statusCode);
  buffer.Write(static_cast<uint8_t>(scanResult.size()));
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult_2& m : scanResult) {
    m.Pack(buffer);
  }
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResponse_2::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResponse_2::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->statusCode);
  buffer.ReadCompoundTypeVArray<Anki::Vector::ExternalComms::RtsWifiScanResult_2, uint8_t>(this->scanResult);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResponse_2::Size() const
{
  size_t result = 0;
  // statusCode
  result += 1; // uint_8
  // scanResult
  result += 1; // uint_8 (array length)
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult_2& m : this->scanResult) {
    result += m.Size();
  }
  return result;
}

bool RtsWifiScanResponse_2::operator==(const RtsWifiScanResponse_2& other) const
{
  return (this->statusCode == other.statusCode &&
    this->scanResult == other.scanResult);
}

bool RtsWifiScanResponse_2::operator!=(const RtsWifiScanResponse_2& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResponse_2VersionHashStr = "5f335f0c517272d55497031475f562e0";

const uint8_t RtsWifiScanResponse_2VersionHash[16] = { 
    0x5f, 0x33, 0x5f, 0xc, 0x51, 0x72, 0x72, 0xd5, 0x54, 0x97, 0x3, 0x14, 0x75, 0xf5, 0x62, 0xe0 
};

// MESSAGE RtsWifiScanResponse_3

RtsWifiScanResponse_3::RtsWifiScanResponse_3(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiScanResponse_3::RtsWifiScanResponse_3(const uint8_t* buff, size_t len)
: RtsWifiScanResponse_3::RtsWifiScanResponse_3({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiScanResponse_3::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiScanResponse_3::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->statusCode);
  buffer.Write(static_cast<uint8_t>(scanResult.size()));
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult_3& m : scanResult) {
    m.Pack(buffer);
  }
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiScanResponse_3::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiScanResponse_3::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->statusCode);
  buffer.ReadCompoundTypeVArray<Anki::Vector::ExternalComms::RtsWifiScanResult_3, uint8_t>(this->scanResult);
  return buffer.GetBytesRead();
}

size_t RtsWifiScanResponse_3::Size() const
{
  size_t result = 0;
  // statusCode
  result += 1; // uint_8
  // scanResult
  result += 1; // uint_8 (array length)
  for (const Anki::Vector::ExternalComms::RtsWifiScanResult_3& m : this->scanResult) {
    result += m.Size();
  }
  return result;
}

bool RtsWifiScanResponse_3::operator==(const RtsWifiScanResponse_3& other) const
{
  return (this->statusCode == other.statusCode &&
    this->scanResult == other.scanResult);
}

bool RtsWifiScanResponse_3::operator!=(const RtsWifiScanResponse_3& other) const
{
  return !(operator==(other));
}


const char* RtsWifiScanResponse_3VersionHashStr = "5589d2032483b9e4160d39091600b335";

const uint8_t RtsWifiScanResponse_3VersionHash[16] = { 
    0x55, 0x89, 0xd2, 0x3, 0x24, 0x83, 0xb9, 0xe4, 0x16, 0xd, 0x39, 0x9, 0x16, 0x0, 0xb3, 0x35 
};

// MESSAGE RtsOtaUpdateRequest

RtsOtaUpdateRequest::RtsOtaUpdateRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsOtaUpdateRequest::RtsOtaUpdateRequest(const uint8_t* buff, size_t len)
: RtsOtaUpdateRequest::RtsOtaUpdateRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsOtaUpdateRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsOtaUpdateRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->url);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsOtaUpdateRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsOtaUpdateRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->url);
  return buffer.GetBytesRead();
}

size_t RtsOtaUpdateRequest::Size() const
{
  size_t result = 0;
  // url
  result += 1; // uint_8 (string length)
  result += this->url.length(); // uint_8
  return result;
}

bool RtsOtaUpdateRequest::operator==(const RtsOtaUpdateRequest& other) const
{
  return (this->url == other.url);
}

bool RtsOtaUpdateRequest::operator!=(const RtsOtaUpdateRequest& other) const
{
  return !(operator==(other));
}


const char* RtsOtaUpdateRequestVersionHashStr = "04cbaabc0cacabff3e7af51e0761325c";

const uint8_t RtsOtaUpdateRequestVersionHash[16] = { 
    0x4, 0xcb, 0xaa, 0xbc, 0xc, 0xac, 0xab, 0xff, 0x3e, 0x7a, 0xf5, 0x1e, 0x7, 0x61, 0x32, 0x5c 
};

// MESSAGE RtsOtaCancelRequest

RtsOtaCancelRequest::RtsOtaCancelRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsOtaCancelRequest::RtsOtaCancelRequest(const uint8_t* buff, size_t len)
: RtsOtaCancelRequest::RtsOtaCancelRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsOtaCancelRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsOtaCancelRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsOtaCancelRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsOtaCancelRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsOtaCancelRequest::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsOtaCancelRequest::operator==(const RtsOtaCancelRequest& other) const
{
return true;
}

bool RtsOtaCancelRequest::operator!=(const RtsOtaCancelRequest& other) const
{
  return !(operator==(other));
}


const char* RtsOtaCancelRequestVersionHashStr = "a2b882158ce1250edbd5c4f33d006d77";

const uint8_t RtsOtaCancelRequestVersionHash[16] = { 
    0xa2, 0xb8, 0x82, 0x15, 0x8c, 0xe1, 0x25, 0xe, 0xdb, 0xd5, 0xc4, 0xf3, 0x3d, 0x0, 0x6d, 0x77 
};

// MESSAGE RtsOtaUpdateResponse

RtsOtaUpdateResponse::RtsOtaUpdateResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsOtaUpdateResponse::RtsOtaUpdateResponse(const uint8_t* buff, size_t len)
: RtsOtaUpdateResponse::RtsOtaUpdateResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsOtaUpdateResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsOtaUpdateResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->status);
  buffer.Write(this->current);
  buffer.Write(this->expected);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsOtaUpdateResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsOtaUpdateResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->status);
  buffer.Read(this->current);
  buffer.Read(this->expected);
  return buffer.GetBytesRead();
}

size_t RtsOtaUpdateResponse::Size() const
{
  size_t result = 0;
  // status
  result += 1; // uint_8
  // current
  result += 8; // uint_64
  // expected
  result += 8; // uint_64
  return result;
}

bool RtsOtaUpdateResponse::operator==(const RtsOtaUpdateResponse& other) const
{
  return (this->status == other.status &&
    this->current == other.current &&
    this->expected == other.expected);
}

bool RtsOtaUpdateResponse::operator!=(const RtsOtaUpdateResponse& other) const
{
  return !(operator==(other));
}


const char* RtsOtaUpdateResponseVersionHashStr = "9e31d73115176dacc3f617b9299daa70";

const uint8_t RtsOtaUpdateResponseVersionHash[16] = { 
    0x9e, 0x31, 0xd7, 0x31, 0x15, 0x17, 0x6d, 0xac, 0xc3, 0xf6, 0x17, 0xb9, 0x29, 0x9d, 0xaa, 0x70 
};

// MESSAGE RtsWifiAccessPointRequest

RtsWifiAccessPointRequest::RtsWifiAccessPointRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiAccessPointRequest::RtsWifiAccessPointRequest(const uint8_t* buff, size_t len)
: RtsWifiAccessPointRequest::RtsWifiAccessPointRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiAccessPointRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiAccessPointRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->enable);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiAccessPointRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiAccessPointRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->enable);
  return buffer.GetBytesRead();
}

size_t RtsWifiAccessPointRequest::Size() const
{
  size_t result = 0;
  // enable
  result += 1; // bool
  return result;
}

bool RtsWifiAccessPointRequest::operator==(const RtsWifiAccessPointRequest& other) const
{
  return (this->enable == other.enable);
}

bool RtsWifiAccessPointRequest::operator!=(const RtsWifiAccessPointRequest& other) const
{
  return !(operator==(other));
}


const char* RtsWifiAccessPointRequestVersionHashStr = "eb7aec802a2a8e28d90550490f0cd80b";

const uint8_t RtsWifiAccessPointRequestVersionHash[16] = { 
    0xeb, 0x7a, 0xec, 0x80, 0x2a, 0x2a, 0x8e, 0x28, 0xd9, 0x5, 0x50, 0x49, 0xf, 0xc, 0xd8, 0xb 
};

// MESSAGE RtsWifiAccessPointResponse

RtsWifiAccessPointResponse::RtsWifiAccessPointResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsWifiAccessPointResponse::RtsWifiAccessPointResponse(const uint8_t* buff, size_t len)
: RtsWifiAccessPointResponse::RtsWifiAccessPointResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsWifiAccessPointResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsWifiAccessPointResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->enabled);
  buffer.WritePString<uint8_t>(this->ssid);
  buffer.WritePString<uint8_t>(this->password);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsWifiAccessPointResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsWifiAccessPointResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->enabled);
  buffer.ReadPString<uint8_t>(this->ssid);
  buffer.ReadPString<uint8_t>(this->password);
  return buffer.GetBytesRead();
}

size_t RtsWifiAccessPointResponse::Size() const
{
  size_t result = 0;
  // enabled
  result += 1; // bool
  // ssid
  result += 1; // uint_8 (string length)
  result += this->ssid.length(); // uint_8
  // password
  result += 1; // uint_8 (string length)
  result += this->password.length(); // uint_8
  return result;
}

bool RtsWifiAccessPointResponse::operator==(const RtsWifiAccessPointResponse& other) const
{
  return (this->enabled == other.enabled &&
    this->ssid == other.ssid &&
    this->password == other.password);
}

bool RtsWifiAccessPointResponse::operator!=(const RtsWifiAccessPointResponse& other) const
{
  return !(operator==(other));
}


const char* RtsWifiAccessPointResponseVersionHashStr = "8fda642c4b2ae2935abf4cde7e424ded";

const uint8_t RtsWifiAccessPointResponseVersionHash[16] = { 
    0x8f, 0xda, 0x64, 0x2c, 0x4b, 0x2a, 0xe2, 0x93, 0x5a, 0xbf, 0x4c, 0xde, 0x7e, 0x42, 0x4d, 0xed 
};

// MESSAGE RtsCancelPairing

RtsCancelPairing::RtsCancelPairing(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsCancelPairing::RtsCancelPairing(const uint8_t* buff, size_t len)
: RtsCancelPairing::RtsCancelPairing({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsCancelPairing::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsCancelPairing::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsCancelPairing::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsCancelPairing::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsCancelPairing::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsCancelPairing::operator==(const RtsCancelPairing& other) const
{
return true;
}

bool RtsCancelPairing::operator!=(const RtsCancelPairing& other) const
{
  return !(operator==(other));
}


const char* RtsCancelPairingVersionHashStr = "2a5b2772a05746d5b1cefd2cf95e7e46";

const uint8_t RtsCancelPairingVersionHash[16] = { 
    0x2a, 0x5b, 0x27, 0x72, 0xa0, 0x57, 0x46, 0xd5, 0xb1, 0xce, 0xfd, 0x2c, 0xf9, 0x5e, 0x7e, 0x46 
};

// MESSAGE RtsForceDisconnect

RtsForceDisconnect::RtsForceDisconnect(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsForceDisconnect::RtsForceDisconnect(const uint8_t* buff, size_t len)
: RtsForceDisconnect::RtsForceDisconnect({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsForceDisconnect::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsForceDisconnect::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsForceDisconnect::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsForceDisconnect::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsForceDisconnect::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsForceDisconnect::operator==(const RtsForceDisconnect& other) const
{
return true;
}

bool RtsForceDisconnect::operator!=(const RtsForceDisconnect& other) const
{
  return !(operator==(other));
}


const char* RtsForceDisconnectVersionHashStr = "421238330b7295b31aebe8750ae7f40a";

const uint8_t RtsForceDisconnectVersionHash[16] = { 
    0x42, 0x12, 0x38, 0x33, 0xb, 0x72, 0x95, 0xb3, 0x1a, 0xeb, 0xe8, 0x75, 0xa, 0xe7, 0xf4, 0xa 
};

// MESSAGE RtsSshRequest

RtsSshRequest::RtsSshRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsSshRequest::RtsSshRequest(const uint8_t* buff, size_t len)
: RtsSshRequest::RtsSshRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsSshRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsSshRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePStringVArray<uint16_t, uint8_t>(this->sshAuthorizedKeyBytes);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsSshRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsSshRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPStringVArray<uint16_t, uint8_t>(this->sshAuthorizedKeyBytes);
  return buffer.GetBytesRead();
}

size_t RtsSshRequest::Size() const
{
  size_t result = 0;
  // sshAuthorizedKeyBytes
  result += 2; // uint_16 (array length)
  result += 1 * this->sshAuthorizedKeyBytes.size(); // uint_8 (string lengths)
  for (const std::string& m : this->sshAuthorizedKeyBytes) {
    result += m.length();
  }
  return result;
}

bool RtsSshRequest::operator==(const RtsSshRequest& other) const
{
  return (this->sshAuthorizedKeyBytes == other.sshAuthorizedKeyBytes);
}

bool RtsSshRequest::operator!=(const RtsSshRequest& other) const
{
  return !(operator==(other));
}


const char* RtsSshRequestVersionHashStr = "a902436210e1b8316cf0212f5c2fb30f";

const uint8_t RtsSshRequestVersionHash[16] = { 
    0xa9, 0x2, 0x43, 0x62, 0x10, 0xe1, 0xb8, 0x31, 0x6c, 0xf0, 0x21, 0x2f, 0x5c, 0x2f, 0xb3, 0xf 
};

// MESSAGE RtsSshResponse

RtsSshResponse::RtsSshResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsSshResponse::RtsSshResponse(const uint8_t* buff, size_t len)
: RtsSshResponse::RtsSshResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsSshResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsSshResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsSshResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsSshResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsSshResponse::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsSshResponse::operator==(const RtsSshResponse& other) const
{
return true;
}

bool RtsSshResponse::operator!=(const RtsSshResponse& other) const
{
  return !(operator==(other));
}


const char* RtsSshResponseVersionHashStr = "585e2e3598a2ee61d0024bd7b4e99583";

const uint8_t RtsSshResponseVersionHash[16] = { 
    0x58, 0x5e, 0x2e, 0x35, 0x98, 0xa2, 0xee, 0x61, 0xd0, 0x2, 0x4b, 0xd7, 0xb4, 0xe9, 0x95, 0x83 
};

// MESSAGE RtsLogRequest

RtsLogRequest::RtsLogRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsLogRequest::RtsLogRequest(const uint8_t* buff, size_t len)
: RtsLogRequest::RtsLogRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsLogRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsLogRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->mode);
  buffer.WritePStringVArray<uint16_t, uint8_t>(this->filter);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsLogRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsLogRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->mode);
  buffer.ReadPStringVArray<uint16_t, uint8_t>(this->filter);
  return buffer.GetBytesRead();
}

size_t RtsLogRequest::Size() const
{
  size_t result = 0;
  // mode
  result += 1; // uint_8
  // filter
  result += 2; // uint_16 (array length)
  result += 1 * this->filter.size(); // uint_8 (string lengths)
  for (const std::string& m : this->filter) {
    result += m.length();
  }
  return result;
}

bool RtsLogRequest::operator==(const RtsLogRequest& other) const
{
  return (this->mode == other.mode &&
    this->filter == other.filter);
}

bool RtsLogRequest::operator!=(const RtsLogRequest& other) const
{
  return !(operator==(other));
}


const char* RtsLogRequestVersionHashStr = "a8363f7f8db3b20e93862cf1714c7f8e";

const uint8_t RtsLogRequestVersionHash[16] = { 
    0xa8, 0x36, 0x3f, 0x7f, 0x8d, 0xb3, 0xb2, 0xe, 0x93, 0x86, 0x2c, 0xf1, 0x71, 0x4c, 0x7f, 0x8e 
};

// MESSAGE RtsLogResponse

RtsLogResponse::RtsLogResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsLogResponse::RtsLogResponse(const uint8_t* buff, size_t len)
: RtsLogResponse::RtsLogResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsLogResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsLogResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->exitCode);
  buffer.Write(this->fileId);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsLogResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsLogResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->exitCode);
  buffer.Read(this->fileId);
  return buffer.GetBytesRead();
}

size_t RtsLogResponse::Size() const
{
  size_t result = 0;
  // exitCode
  result += 1; // uint_8
  // fileId
  result += 4; // uint_32
  return result;
}

bool RtsLogResponse::operator==(const RtsLogResponse& other) const
{
  return (this->exitCode == other.exitCode &&
    this->fileId == other.fileId);
}

bool RtsLogResponse::operator!=(const RtsLogResponse& other) const
{
  return !(operator==(other));
}


const char* RtsLogResponseVersionHashStr = "96318d43f2701739be951619c723a5e8";

const uint8_t RtsLogResponseVersionHash[16] = { 
    0x96, 0x31, 0x8d, 0x43, 0xf2, 0x70, 0x17, 0x39, 0xbe, 0x95, 0x16, 0x19, 0xc7, 0x23, 0xa5, 0xe8 
};

// MESSAGE RtsFileDownload

RtsFileDownload::RtsFileDownload(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsFileDownload::RtsFileDownload(const uint8_t* buff, size_t len)
: RtsFileDownload::RtsFileDownload({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsFileDownload::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsFileDownload::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->status);
  buffer.Write(this->fileId);
  buffer.Write(this->packetNumber);
  buffer.Write(this->packetTotal);
  buffer.WriteVArray<uint8_t, uint16_t>(this->fileChunk);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsFileDownload::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsFileDownload::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->status);
  buffer.Read(this->fileId);
  buffer.Read(this->packetNumber);
  buffer.Read(this->packetTotal);
  buffer.ReadVArray<uint8_t, uint16_t>(this->fileChunk);
  return buffer.GetBytesRead();
}

size_t RtsFileDownload::Size() const
{
  size_t result = 0;
  // status
  result += 1; // uint_8
  // fileId
  result += 4; // uint_32
  // packetNumber
  result += 4; // uint_32
  // packetTotal
  result += 4; // uint_32
  // fileChunk
  result += 2; // uint_16 (array length)
  result += 1 * this->fileChunk.size(); // uint_8
  return result;
}

bool RtsFileDownload::operator==(const RtsFileDownload& other) const
{
  return (this->status == other.status &&
    this->fileId == other.fileId &&
    this->packetNumber == other.packetNumber &&
    this->packetTotal == other.packetTotal &&
    this->fileChunk == other.fileChunk);
}

bool RtsFileDownload::operator!=(const RtsFileDownload& other) const
{
  return !(operator==(other));
}


const char* RtsFileDownloadVersionHashStr = "4f891e5d9780a34c963c3902e33bccd2";

const uint8_t RtsFileDownloadVersionHash[16] = { 
    0x4f, 0x89, 0x1e, 0x5d, 0x97, 0x80, 0xa3, 0x4c, 0x96, 0x3c, 0x39, 0x2, 0xe3, 0x3b, 0xcc, 0xd2 
};

// MESSAGE RtsCloudSessionRequest

RtsCloudSessionRequest::RtsCloudSessionRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsCloudSessionRequest::RtsCloudSessionRequest(const uint8_t* buff, size_t len)
: RtsCloudSessionRequest::RtsCloudSessionRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsCloudSessionRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsCloudSessionRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint16_t>(this->sessionToken);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsCloudSessionRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsCloudSessionRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint16_t>(this->sessionToken);
  return buffer.GetBytesRead();
}

size_t RtsCloudSessionRequest::Size() const
{
  size_t result = 0;
  // sessionToken
  result += 2; // uint_16 (string length)
  result += this->sessionToken.length(); // uint_8
  return result;
}

bool RtsCloudSessionRequest::operator==(const RtsCloudSessionRequest& other) const
{
  return (this->sessionToken == other.sessionToken);
}

bool RtsCloudSessionRequest::operator!=(const RtsCloudSessionRequest& other) const
{
  return !(operator==(other));
}


const char* RtsCloudSessionRequestVersionHashStr = "4a361608610fedd12e45dea9f02bbe15";

const uint8_t RtsCloudSessionRequestVersionHash[16] = { 
    0x4a, 0x36, 0x16, 0x8, 0x61, 0xf, 0xed, 0xd1, 0x2e, 0x45, 0xde, 0xa9, 0xf0, 0x2b, 0xbe, 0x15 
};

// MESSAGE RtsCloudSessionRequest_2

RtsCloudSessionRequest_2::RtsCloudSessionRequest_2(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsCloudSessionRequest_2::RtsCloudSessionRequest_2(const uint8_t* buff, size_t len)
: RtsCloudSessionRequest_2::RtsCloudSessionRequest_2({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsCloudSessionRequest_2::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsCloudSessionRequest_2::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint16_t>(this->sessionToken);
  buffer.WritePString<uint8_t>(this->clientName);
  buffer.WritePString<uint8_t>(this->appId);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsCloudSessionRequest_2::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsCloudSessionRequest_2::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint16_t>(this->sessionToken);
  buffer.ReadPString<uint8_t>(this->clientName);
  buffer.ReadPString<uint8_t>(this->appId);
  return buffer.GetBytesRead();
}

size_t RtsCloudSessionRequest_2::Size() const
{
  size_t result = 0;
  // sessionToken
  result += 2; // uint_16 (string length)
  result += this->sessionToken.length(); // uint_8
  // clientName
  result += 1; // uint_8 (string length)
  result += this->clientName.length(); // uint_8
  // appId
  result += 1; // uint_8 (string length)
  result += this->appId.length(); // uint_8
  return result;
}

bool RtsCloudSessionRequest_2::operator==(const RtsCloudSessionRequest_2& other) const
{
  return (this->sessionToken == other.sessionToken &&
    this->clientName == other.clientName &&
    this->appId == other.appId);
}

bool RtsCloudSessionRequest_2::operator!=(const RtsCloudSessionRequest_2& other) const
{
  return !(operator==(other));
}


const char* RtsCloudSessionRequest_2VersionHashStr = "dd93fd23138cf5f89794e3d9ddaf0f7a";

const uint8_t RtsCloudSessionRequest_2VersionHash[16] = { 
    0xdd, 0x93, 0xfd, 0x23, 0x13, 0x8c, 0xf5, 0xf8, 0x97, 0x94, 0xe3, 0xd9, 0xdd, 0xaf, 0xf, 0x7a 
};

// MESSAGE RtsCloudSessionResponse

RtsCloudSessionResponse::RtsCloudSessionResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsCloudSessionResponse::RtsCloudSessionResponse(const uint8_t* buff, size_t len)
: RtsCloudSessionResponse::RtsCloudSessionResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsCloudSessionResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsCloudSessionResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->success);
  buffer.Write(this->statusCode);
  buffer.WritePString<uint16_t>(this->clientTokenGuid);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsCloudSessionResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsCloudSessionResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->success);
  buffer.Read(this->statusCode);
  buffer.ReadPString<uint16_t>(this->clientTokenGuid);
  return buffer.GetBytesRead();
}

size_t RtsCloudSessionResponse::Size() const
{
  size_t result = 0;
  // success
  result += 1; // bool
  // statusCode
  result += 1; // RtsCloudStatus
  // clientTokenGuid
  result += 2; // uint_16 (string length)
  result += this->clientTokenGuid.length(); // uint_8
  return result;
}

bool RtsCloudSessionResponse::operator==(const RtsCloudSessionResponse& other) const
{
  return (this->success == other.success &&
    this->statusCode == other.statusCode &&
    this->clientTokenGuid == other.clientTokenGuid);
}

bool RtsCloudSessionResponse::operator!=(const RtsCloudSessionResponse& other) const
{
  return !(operator==(other));
}


const char* RtsCloudSessionResponseVersionHashStr = "fa6ad327c2c7eaed2681d273f8829d90";

const uint8_t RtsCloudSessionResponseVersionHash[16] = { 
    0xfa, 0x6a, 0xd3, 0x27, 0xc2, 0xc7, 0xea, 0xed, 0x26, 0x81, 0xd2, 0x73, 0xf8, 0x82, 0x9d, 0x90 
};

// MESSAGE RtsAppConnectionIdRequest

RtsAppConnectionIdRequest::RtsAppConnectionIdRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsAppConnectionIdRequest::RtsAppConnectionIdRequest(const uint8_t* buff, size_t len)
: RtsAppConnectionIdRequest::RtsAppConnectionIdRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsAppConnectionIdRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsAppConnectionIdRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint16_t>(this->connectionId);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsAppConnectionIdRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsAppConnectionIdRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint16_t>(this->connectionId);
  return buffer.GetBytesRead();
}

size_t RtsAppConnectionIdRequest::Size() const
{
  size_t result = 0;
  // connectionId
  result += 2; // uint_16 (string length)
  result += this->connectionId.length(); // uint_8
  return result;
}

bool RtsAppConnectionIdRequest::operator==(const RtsAppConnectionIdRequest& other) const
{
  return (this->connectionId == other.connectionId);
}

bool RtsAppConnectionIdRequest::operator!=(const RtsAppConnectionIdRequest& other) const
{
  return !(operator==(other));
}


const char* RtsAppConnectionIdRequestVersionHashStr = "6f1adfb53a52356fddac8a003618392b";

const uint8_t RtsAppConnectionIdRequestVersionHash[16] = { 
    0x6f, 0x1a, 0xdf, 0xb5, 0x3a, 0x52, 0x35, 0x6f, 0xdd, 0xac, 0x8a, 0x0, 0x36, 0x18, 0x39, 0x2b 
};

// MESSAGE RtsAppConnectionIdResponse

RtsAppConnectionIdResponse::RtsAppConnectionIdResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsAppConnectionIdResponse::RtsAppConnectionIdResponse(const uint8_t* buff, size_t len)
: RtsAppConnectionIdResponse::RtsAppConnectionIdResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsAppConnectionIdResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsAppConnectionIdResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsAppConnectionIdResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsAppConnectionIdResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t RtsAppConnectionIdResponse::Size() const
{
  size_t result = 0;
  return result;
}

bool RtsAppConnectionIdResponse::operator==(const RtsAppConnectionIdResponse& other) const
{
return true;
}

bool RtsAppConnectionIdResponse::operator!=(const RtsAppConnectionIdResponse& other) const
{
  return !(operator==(other));
}


const char* RtsAppConnectionIdResponseVersionHashStr = "7c746c5bbb9f5df0eae86b5c6a89e07b";

const uint8_t RtsAppConnectionIdResponseVersionHash[16] = { 
    0x7c, 0x74, 0x6c, 0x5b, 0xbb, 0x9f, 0x5d, 0xf0, 0xea, 0xe8, 0x6b, 0x5c, 0x6a, 0x89, 0xe0, 0x7b 
};

// MESSAGE RtsResponse

RtsResponse::RtsResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsResponse::RtsResponse(const uint8_t* buff, size_t len)
: RtsResponse::RtsResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(this->code);
  buffer.WritePString<uint16_t>(this->responseMessage);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.Read(this->code);
  buffer.ReadPString<uint16_t>(this->responseMessage);
  return buffer.GetBytesRead();
}

size_t RtsResponse::Size() const
{
  size_t result = 0;
  // code
  result += 2; // RtsResponseCode
  // responseMessage
  result += 2; // uint_16 (string length)
  result += this->responseMessage.length(); // uint_8
  return result;
}

bool RtsResponse::operator==(const RtsResponse& other) const
{
  return (this->code == other.code &&
    this->responseMessage == other.responseMessage);
}

bool RtsResponse::operator!=(const RtsResponse& other) const
{
  return !(operator==(other));
}


const char* RtsResponseVersionHashStr = "6654bf79b167206af5aac44fd5f7ef45";

const uint8_t RtsResponseVersionHash[16] = { 
    0x66, 0x54, 0xbf, 0x79, 0xb1, 0x67, 0x20, 0x6a, 0xf5, 0xaa, 0xc4, 0x4f, 0xd5, 0xf7, 0xef, 0x45 
};

// MESSAGE RtsSdkProxyRequest

RtsSdkProxyRequest::RtsSdkProxyRequest(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsSdkProxyRequest::RtsSdkProxyRequest(const uint8_t* buff, size_t len)
: RtsSdkProxyRequest::RtsSdkProxyRequest({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsSdkProxyRequest::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsSdkProxyRequest::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->clientGuid);
  buffer.WritePString<uint8_t>(this->messageId);
  buffer.WritePString<uint8_t>(this->urlPath);
  buffer.WritePString<uint16_t>(this->json);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsSdkProxyRequest::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsSdkProxyRequest::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->clientGuid);
  buffer.ReadPString<uint8_t>(this->messageId);
  buffer.ReadPString<uint8_t>(this->urlPath);
  buffer.ReadPString<uint16_t>(this->json);
  return buffer.GetBytesRead();
}

size_t RtsSdkProxyRequest::Size() const
{
  size_t result = 0;
  // clientGuid
  result += 1; // uint_8 (string length)
  result += this->clientGuid.length(); // uint_8
  // messageId
  result += 1; // uint_8 (string length)
  result += this->messageId.length(); // uint_8
  // urlPath
  result += 1; // uint_8 (string length)
  result += this->urlPath.length(); // uint_8
  // json
  result += 2; // uint_16 (string length)
  result += this->json.length(); // uint_8
  return result;
}

bool RtsSdkProxyRequest::operator==(const RtsSdkProxyRequest& other) const
{
  return (this->clientGuid == other.clientGuid &&
    this->messageId == other.messageId &&
    this->urlPath == other.urlPath &&
    this->json == other.json);
}

bool RtsSdkProxyRequest::operator!=(const RtsSdkProxyRequest& other) const
{
  return !(operator==(other));
}


const char* RtsSdkProxyRequestVersionHashStr = "481b5a2ef6f501a6d616a68f4e5acb88";

const uint8_t RtsSdkProxyRequestVersionHash[16] = { 
    0x48, 0x1b, 0x5a, 0x2e, 0xf6, 0xf5, 0x1, 0xa6, 0xd6, 0x16, 0xa6, 0x8f, 0x4e, 0x5a, 0xcb, 0x88 
};

// MESSAGE RtsSdkProxyResponse

RtsSdkProxyResponse::RtsSdkProxyResponse(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

RtsSdkProxyResponse::RtsSdkProxyResponse(const uint8_t* buff, size_t len)
: RtsSdkProxyResponse::RtsSdkProxyResponse({const_cast<uint8_t*>(buff), len, false})
{
}

size_t RtsSdkProxyResponse::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsSdkProxyResponse::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.WritePString<uint8_t>(this->messageId);
  buffer.Write(this->statusCode);
  buffer.WritePString<uint8_t>(this->responseType);
  buffer.WritePString<uint16_t>(this->responseBody);
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t RtsSdkProxyResponse::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsSdkProxyResponse::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  buffer.ReadPString<uint8_t>(this->messageId);
  buffer.Read(this->statusCode);
  buffer.ReadPString<uint8_t>(this->responseType);
  buffer.ReadPString<uint16_t>(this->responseBody);
  return buffer.GetBytesRead();
}

size_t RtsSdkProxyResponse::Size() const
{
  size_t result = 0;
  // messageId
  result += 1; // uint_8 (string length)
  result += this->messageId.length(); // uint_8
  // statusCode
  result += 2; // uint_16
  // responseType
  result += 1; // uint_8 (string length)
  result += this->responseType.length(); // uint_8
  // responseBody
  result += 2; // uint_16 (string length)
  result += this->responseBody.length(); // uint_8
  return result;
}

bool RtsSdkProxyResponse::operator==(const RtsSdkProxyResponse& other) const
{
  return (this->messageId == other.messageId &&
    this->statusCode == other.statusCode &&
    this->responseType == other.responseType &&
    this->responseBody == other.responseBody);
}

bool RtsSdkProxyResponse::operator!=(const RtsSdkProxyResponse& other) const
{
  return !(operator==(other));
}


const char* RtsSdkProxyResponseVersionHashStr = "84142461fc1d020c13e951919cac1a0c";

const uint8_t RtsSdkProxyResponseVersionHash[16] = { 
    0x84, 0x14, 0x24, 0x61, 0xfc, 0x1d, 0x2, 0xc, 0x13, 0xe9, 0x51, 0x91, 0x9c, 0xac, 0x1a, 0xc 
};

// MESSAGE Error

Error::Error(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

Error::Error(const uint8_t* buff, size_t len)
: Error::Error({const_cast<uint8_t*>(buff), len, false})
{
}

size_t Error::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t Error::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t Error::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t Error::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t Error::Size() const
{
  size_t result = 0;
  return result;
}

bool Error::operator==(const Error& other) const
{
return true;
}

bool Error::operator!=(const Error& other) const
{
  return !(operator==(other));
}


const char* ErrorVersionHashStr = "b895feaac225b233546cc3c52cdd9b4d";

const uint8_t ErrorVersionHash[16] = { 
    0xb8, 0x95, 0xfe, 0xaa, 0xc2, 0x25, 0xb2, 0x33, 0x54, 0x6c, 0xc3, 0xc5, 0x2c, 0xdd, 0x9b, 0x4d 
};

// UNION RtsConnection_2

RtsConnection_2::RtsConnection_2(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection_2::RtsConnection_2(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection_2::RtsConnection_2(const RtsConnection_2& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(other._RtsWifiConnectResponse);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_2:
    new(&(this->_RtsStatusResponse_2)) Anki::Vector::ExternalComms::RtsStatusResponse_2(other._RtsStatusResponse_2);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_2:
    new(&(this->_RtsWifiScanResponse_2)) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(other._RtsWifiScanResponse_2);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection_2::RtsConnection_2(RtsConnection_2&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(other._RtsWifiConnectResponse));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_2:
    new(&(this->_RtsStatusResponse_2)) Anki::Vector::ExternalComms::RtsStatusResponse_2(std::move(other._RtsStatusResponse_2));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_2:
    new(&(this->_RtsWifiScanResponse_2)) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(std::move(other._RtsWifiScanResponse_2));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection_2& RtsConnection_2::operator=(const RtsConnection_2& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(other._RtsWifiConnectResponse);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_2:
    new(&(this->_RtsStatusResponse_2)) Anki::Vector::ExternalComms::RtsStatusResponse_2(other._RtsStatusResponse_2);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_2:
    new(&(this->_RtsWifiScanResponse_2)) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(other._RtsWifiScanResponse_2);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection_2& RtsConnection_2::operator=(RtsConnection_2&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(other._RtsWifiConnectResponse));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_2:
    new(&(this->_RtsStatusResponse_2)) Anki::Vector::ExternalComms::RtsStatusResponse_2(std::move(other._RtsStatusResponse_2));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_2:
    new(&(this->_RtsWifiScanResponse_2)) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(std::move(other._RtsWifiScanResponse_2));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection_2 RtsConnection_2::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection_2 m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection_2::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection_2::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection_2::Get_<RtsConnection_2::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection_2::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  RtsConnection_2 m;
  m.Set_RtsConnRequest(new_RtsConnRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
  _tag = Tag::RtsConnRequest;
}

const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_2::Get_RtsConnRequest() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

void RtsConnection_2::Set_RtsConnRequest(const Anki::Vector::ExternalComms::RtsConnRequest& new_RtsConnRequest)
{
  if(this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = new_RtsConnRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(new_RtsConnRequest);
    _tag = Tag::RtsConnRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsConnRequest>() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsConnRequest>(Anki::Vector::ExternalComms::RtsConnRequest member)
{
  return CreateRtsConnRequest(std::move(member));
}

void RtsConnection_2::Set_RtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  if (this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = std::move(new_RtsConnRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
    _tag = Tag::RtsConnRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  RtsConnection_2 m;
  m.Set_RtsConnResponse(new_RtsConnResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
  _tag = Tag::RtsConnResponse;
}

const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_2::Get_RtsConnResponse() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

void RtsConnection_2::Set_RtsConnResponse(const Anki::Vector::ExternalComms::RtsConnResponse& new_RtsConnResponse)
{
  if(this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = new_RtsConnResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(new_RtsConnResponse);
    _tag = Tag::RtsConnResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsConnResponse>() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsConnResponse>(Anki::Vector::ExternalComms::RtsConnResponse member)
{
  return CreateRtsConnResponse(std::move(member));
}

void RtsConnection_2::Set_RtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  if (this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = std::move(new_RtsConnResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
    _tag = Tag::RtsConnResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  RtsConnection_2 m;
  m.Set_RtsNonceMessage(new_RtsNonceMessage);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
  _tag = Tag::RtsNonceMessage;
}

const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_2::Get_RtsNonceMessage() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

void RtsConnection_2::Set_RtsNonceMessage(const Anki::Vector::ExternalComms::RtsNonceMessage& new_RtsNonceMessage)
{
  if(this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = new_RtsNonceMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(new_RtsNonceMessage);
    _tag = Tag::RtsNonceMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsNonceMessage>() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsNonceMessage>(Anki::Vector::ExternalComms::RtsNonceMessage member)
{
  return CreateRtsNonceMessage(std::move(member));
}

void RtsConnection_2::Set_RtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  if (this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = std::move(new_RtsNonceMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
    _tag = Tag::RtsNonceMessage;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  RtsConnection_2 m;
  m.Set_RtsChallengeMessage(new_RtsChallengeMessage);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
  _tag = Tag::RtsChallengeMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_2::Get_RtsChallengeMessage() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

void RtsConnection_2::Set_RtsChallengeMessage(const Anki::Vector::ExternalComms::RtsChallengeMessage& new_RtsChallengeMessage)
{
  if(this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = new_RtsChallengeMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(new_RtsChallengeMessage);
    _tag = Tag::RtsChallengeMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsChallengeMessage>() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsChallengeMessage>(Anki::Vector::ExternalComms::RtsChallengeMessage member)
{
  return CreateRtsChallengeMessage(std::move(member));
}

void RtsConnection_2::Set_RtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  if (this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = std::move(new_RtsChallengeMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
    _tag = Tag::RtsChallengeMessage;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  RtsConnection_2 m;
  m.Set_RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
  _tag = Tag::RtsChallengeSuccessMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_2::Get_RtsChallengeSuccessMessage() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

void RtsConnection_2::Set_RtsChallengeSuccessMessage(const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& new_RtsChallengeSuccessMessage)
{
  if(this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = new_RtsChallengeSuccessMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsChallengeSuccessMessage>() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsChallengeSuccessMessage>(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage member)
{
  return CreateRtsChallengeSuccessMessage(std::move(member));
}

void RtsConnection_2::Set_RtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  if (this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = std::move(new_RtsChallengeSuccessMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  RtsConnection_2 m;
  m.Set_RtsWifiConnectRequest(new_RtsWifiConnectRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
  _tag = Tag::RtsWifiConnectRequest;
}

const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_2::Get_RtsWifiConnectRequest() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

void RtsConnection_2::Set_RtsWifiConnectRequest(const Anki::Vector::ExternalComms::RtsWifiConnectRequest& new_RtsWifiConnectRequest)
{
  if(this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = new_RtsWifiConnectRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(new_RtsWifiConnectRequest);
    _tag = Tag::RtsWifiConnectRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiConnectRequest>() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiConnectRequest>(Anki::Vector::ExternalComms::RtsWifiConnectRequest member)
{
  return CreateRtsWifiConnectRequest(std::move(member));
}

void RtsConnection_2::Set_RtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  if (this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = std::move(new_RtsWifiConnectRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
    _tag = Tag::RtsWifiConnectRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiConnectResponse(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  RtsConnection_2 m;
  m.Set_RtsWifiConnectResponse(new_RtsWifiConnectResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(new_RtsWifiConnectResponse));
  _tag = Tag::RtsWifiConnectResponse;
}

const Anki::Vector::ExternalComms::RtsWifiConnectResponse& RtsConnection_2::Get_RtsWifiConnectResponse() const
{
  assert(_tag == Tag::RtsWifiConnectResponse);
  return this->_RtsWifiConnectResponse;
}

void RtsConnection_2::Set_RtsWifiConnectResponse(const Anki::Vector::ExternalComms::RtsWifiConnectResponse& new_RtsWifiConnectResponse)
{
  if(this->_tag == Tag::RtsWifiConnectResponse) {
    this->_RtsWifiConnectResponse = new_RtsWifiConnectResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(new_RtsWifiConnectResponse);
    _tag = Tag::RtsWifiConnectResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiConnectResponse>() const
{
  assert(_tag == Tag::RtsWifiConnectResponse);
  return this->_RtsWifiConnectResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiConnectResponse>(Anki::Vector::ExternalComms::RtsWifiConnectResponse member)
{
  return CreateRtsWifiConnectResponse(std::move(member));
}

void RtsConnection_2::Set_RtsWifiConnectResponse(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  if (this->_tag == Tag::RtsWifiConnectResponse) {
    this->_RtsWifiConnectResponse = std::move(new_RtsWifiConnectResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(new_RtsWifiConnectResponse));
    _tag = Tag::RtsWifiConnectResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  RtsConnection_2 m;
  m.Set_RtsWifiIpRequest(new_RtsWifiIpRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
  _tag = Tag::RtsWifiIpRequest;
}

const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_2::Get_RtsWifiIpRequest() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

void RtsConnection_2::Set_RtsWifiIpRequest(const Anki::Vector::ExternalComms::RtsWifiIpRequest& new_RtsWifiIpRequest)
{
  if(this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = new_RtsWifiIpRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(new_RtsWifiIpRequest);
    _tag = Tag::RtsWifiIpRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiIpRequest>() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiIpRequest>(Anki::Vector::ExternalComms::RtsWifiIpRequest member)
{
  return CreateRtsWifiIpRequest(std::move(member));
}

void RtsConnection_2::Set_RtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  if (this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = std::move(new_RtsWifiIpRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
    _tag = Tag::RtsWifiIpRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  RtsConnection_2 m;
  m.Set_RtsWifiIpResponse(new_RtsWifiIpResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
  _tag = Tag::RtsWifiIpResponse;
}

const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_2::Get_RtsWifiIpResponse() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

void RtsConnection_2::Set_RtsWifiIpResponse(const Anki::Vector::ExternalComms::RtsWifiIpResponse& new_RtsWifiIpResponse)
{
  if(this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = new_RtsWifiIpResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(new_RtsWifiIpResponse);
    _tag = Tag::RtsWifiIpResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiIpResponse>() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiIpResponse>(Anki::Vector::ExternalComms::RtsWifiIpResponse member)
{
  return CreateRtsWifiIpResponse(std::move(member));
}

void RtsConnection_2::Set_RtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  if (this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = std::move(new_RtsWifiIpResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
    _tag = Tag::RtsWifiIpResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  RtsConnection_2 m;
  m.Set_RtsStatusRequest(new_RtsStatusRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
  _tag = Tag::RtsStatusRequest;
}

const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_2::Get_RtsStatusRequest() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

void RtsConnection_2::Set_RtsStatusRequest(const Anki::Vector::ExternalComms::RtsStatusRequest& new_RtsStatusRequest)
{
  if(this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = new_RtsStatusRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(new_RtsStatusRequest);
    _tag = Tag::RtsStatusRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsStatusRequest>() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsStatusRequest>(Anki::Vector::ExternalComms::RtsStatusRequest member)
{
  return CreateRtsStatusRequest(std::move(member));
}

void RtsConnection_2::Set_RtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  if (this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = std::move(new_RtsStatusRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
    _tag = Tag::RtsStatusRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsStatusResponse_2(Anki::Vector::ExternalComms::RtsStatusResponse_2&& new_RtsStatusResponse_2)
{
  RtsConnection_2 m;
  m.Set_RtsStatusResponse_2(new_RtsStatusResponse_2);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsStatusResponse_2&& new_RtsStatusResponse_2)
{
  new(&this->_RtsStatusResponse_2) Anki::Vector::ExternalComms::RtsStatusResponse_2(std::move(new_RtsStatusResponse_2));
  _tag = Tag::RtsStatusResponse_2;
}

const Anki::Vector::ExternalComms::RtsStatusResponse_2& RtsConnection_2::Get_RtsStatusResponse_2() const
{
  assert(_tag == Tag::RtsStatusResponse_2);
  return this->_RtsStatusResponse_2;
}

void RtsConnection_2::Set_RtsStatusResponse_2(const Anki::Vector::ExternalComms::RtsStatusResponse_2& new_RtsStatusResponse_2)
{
  if(this->_tag == Tag::RtsStatusResponse_2) {
    this->_RtsStatusResponse_2 = new_RtsStatusResponse_2;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_2) Anki::Vector::ExternalComms::RtsStatusResponse_2(new_RtsStatusResponse_2);
    _tag = Tag::RtsStatusResponse_2;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusResponse_2& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsStatusResponse_2>() const
{
  assert(_tag == Tag::RtsStatusResponse_2);
  return this->_RtsStatusResponse_2;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsStatusResponse_2>(Anki::Vector::ExternalComms::RtsStatusResponse_2 member)
{
  return CreateRtsStatusResponse_2(std::move(member));
}

void RtsConnection_2::Set_RtsStatusResponse_2(Anki::Vector::ExternalComms::RtsStatusResponse_2&& new_RtsStatusResponse_2)
{
  if (this->_tag == Tag::RtsStatusResponse_2) {
    this->_RtsStatusResponse_2 = std::move(new_RtsStatusResponse_2);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_2) Anki::Vector::ExternalComms::RtsStatusResponse_2(std::move(new_RtsStatusResponse_2));
    _tag = Tag::RtsStatusResponse_2;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  RtsConnection_2 m;
  m.Set_RtsWifiScanRequest(new_RtsWifiScanRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
  _tag = Tag::RtsWifiScanRequest;
}

const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_2::Get_RtsWifiScanRequest() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

void RtsConnection_2::Set_RtsWifiScanRequest(const Anki::Vector::ExternalComms::RtsWifiScanRequest& new_RtsWifiScanRequest)
{
  if(this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = new_RtsWifiScanRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(new_RtsWifiScanRequest);
    _tag = Tag::RtsWifiScanRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiScanRequest>() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiScanRequest>(Anki::Vector::ExternalComms::RtsWifiScanRequest member)
{
  return CreateRtsWifiScanRequest(std::move(member));
}

void RtsConnection_2::Set_RtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  if (this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = std::move(new_RtsWifiScanRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
    _tag = Tag::RtsWifiScanRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiScanResponse_2(Anki::Vector::ExternalComms::RtsWifiScanResponse_2&& new_RtsWifiScanResponse_2)
{
  RtsConnection_2 m;
  m.Set_RtsWifiScanResponse_2(new_RtsWifiScanResponse_2);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiScanResponse_2&& new_RtsWifiScanResponse_2)
{
  new(&this->_RtsWifiScanResponse_2) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(std::move(new_RtsWifiScanResponse_2));
  _tag = Tag::RtsWifiScanResponse_2;
}

const Anki::Vector::ExternalComms::RtsWifiScanResponse_2& RtsConnection_2::Get_RtsWifiScanResponse_2() const
{
  assert(_tag == Tag::RtsWifiScanResponse_2);
  return this->_RtsWifiScanResponse_2;
}

void RtsConnection_2::Set_RtsWifiScanResponse_2(const Anki::Vector::ExternalComms::RtsWifiScanResponse_2& new_RtsWifiScanResponse_2)
{
  if(this->_tag == Tag::RtsWifiScanResponse_2) {
    this->_RtsWifiScanResponse_2 = new_RtsWifiScanResponse_2;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_2) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(new_RtsWifiScanResponse_2);
    _tag = Tag::RtsWifiScanResponse_2;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanResponse_2& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiScanResponse_2>() const
{
  assert(_tag == Tag::RtsWifiScanResponse_2);
  return this->_RtsWifiScanResponse_2;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiScanResponse_2>(Anki::Vector::ExternalComms::RtsWifiScanResponse_2 member)
{
  return CreateRtsWifiScanResponse_2(std::move(member));
}

void RtsConnection_2::Set_RtsWifiScanResponse_2(Anki::Vector::ExternalComms::RtsWifiScanResponse_2&& new_RtsWifiScanResponse_2)
{
  if (this->_tag == Tag::RtsWifiScanResponse_2) {
    this->_RtsWifiScanResponse_2 = std::move(new_RtsWifiScanResponse_2);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_2) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(std::move(new_RtsWifiScanResponse_2));
    _tag = Tag::RtsWifiScanResponse_2;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  RtsConnection_2 m;
  m.Set_RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
  _tag = Tag::RtsOtaUpdateRequest;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_2::Get_RtsOtaUpdateRequest() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

void RtsConnection_2::Set_RtsOtaUpdateRequest(const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& new_RtsOtaUpdateRequest)
{
  if(this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = new_RtsOtaUpdateRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsOtaUpdateRequest>() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsOtaUpdateRequest>(Anki::Vector::ExternalComms::RtsOtaUpdateRequest member)
{
  return CreateRtsOtaUpdateRequest(std::move(member));
}

void RtsConnection_2::Set_RtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  if (this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = std::move(new_RtsOtaUpdateRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  RtsConnection_2 m;
  m.Set_RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
  _tag = Tag::RtsOtaUpdateResponse;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_2::Get_RtsOtaUpdateResponse() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

void RtsConnection_2::Set_RtsOtaUpdateResponse(const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& new_RtsOtaUpdateResponse)
{
  if(this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = new_RtsOtaUpdateResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsOtaUpdateResponse>() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsOtaUpdateResponse>(Anki::Vector::ExternalComms::RtsOtaUpdateResponse member)
{
  return CreateRtsOtaUpdateResponse(std::move(member));
}

void RtsConnection_2::Set_RtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  if (this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = std::move(new_RtsOtaUpdateResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  RtsConnection_2 m;
  m.Set_RtsCancelPairing(new_RtsCancelPairing);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
  _tag = Tag::RtsCancelPairing;
}

const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_2::Get_RtsCancelPairing() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

void RtsConnection_2::Set_RtsCancelPairing(const Anki::Vector::ExternalComms::RtsCancelPairing& new_RtsCancelPairing)
{
  if(this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = new_RtsCancelPairing;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(new_RtsCancelPairing);
    _tag = Tag::RtsCancelPairing;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsCancelPairing>() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsCancelPairing>(Anki::Vector::ExternalComms::RtsCancelPairing member)
{
  return CreateRtsCancelPairing(std::move(member));
}

void RtsConnection_2::Set_RtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  if (this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = std::move(new_RtsCancelPairing);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
    _tag = Tag::RtsCancelPairing;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  RtsConnection_2 m;
  m.Set_RtsForceDisconnect(new_RtsForceDisconnect);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
  _tag = Tag::RtsForceDisconnect;
}

const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_2::Get_RtsForceDisconnect() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

void RtsConnection_2::Set_RtsForceDisconnect(const Anki::Vector::ExternalComms::RtsForceDisconnect& new_RtsForceDisconnect)
{
  if(this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = new_RtsForceDisconnect;
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(new_RtsForceDisconnect);
    _tag = Tag::RtsForceDisconnect;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsForceDisconnect>() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsForceDisconnect>(Anki::Vector::ExternalComms::RtsForceDisconnect member)
{
  return CreateRtsForceDisconnect(std::move(member));
}

void RtsConnection_2::Set_RtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  if (this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = std::move(new_RtsForceDisconnect);
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
    _tag = Tag::RtsForceDisconnect;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  RtsConnection_2 m;
  m.Set_RtsAck(new_RtsAck);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
  _tag = Tag::RtsAck;
}

const Anki::Vector::ExternalComms::RtsAck& RtsConnection_2::Get_RtsAck() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

void RtsConnection_2::Set_RtsAck(const Anki::Vector::ExternalComms::RtsAck& new_RtsAck)
{
  if(this->_tag == Tag::RtsAck) {
    this->_RtsAck = new_RtsAck;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(new_RtsAck);
    _tag = Tag::RtsAck;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAck& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsAck>() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsAck>(Anki::Vector::ExternalComms::RtsAck member)
{
  return CreateRtsAck(std::move(member));
}

void RtsConnection_2::Set_RtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  if (this->_tag == Tag::RtsAck) {
    this->_RtsAck = std::move(new_RtsAck);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
    _tag = Tag::RtsAck;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  RtsConnection_2 m;
  m.Set_RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
  _tag = Tag::RtsWifiAccessPointRequest;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_2::Get_RtsWifiAccessPointRequest() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

void RtsConnection_2::Set_RtsWifiAccessPointRequest(const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& new_RtsWifiAccessPointRequest)
{
  if(this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = new_RtsWifiAccessPointRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiAccessPointRequest>() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiAccessPointRequest>(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest member)
{
  return CreateRtsWifiAccessPointRequest(std::move(member));
}

void RtsConnection_2::Set_RtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  if (this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = std::move(new_RtsWifiAccessPointRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  RtsConnection_2 m;
  m.Set_RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
  _tag = Tag::RtsWifiAccessPointResponse;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_2::Get_RtsWifiAccessPointResponse() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

void RtsConnection_2::Set_RtsWifiAccessPointResponse(const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& new_RtsWifiAccessPointResponse)
{
  if(this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = new_RtsWifiAccessPointResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsWifiAccessPointResponse>() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsWifiAccessPointResponse>(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse member)
{
  return CreateRtsWifiAccessPointResponse(std::move(member));
}

void RtsConnection_2::Set_RtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  if (this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = std::move(new_RtsWifiAccessPointResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  RtsConnection_2 m;
  m.Set_RtsSshRequest(new_RtsSshRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
  _tag = Tag::RtsSshRequest;
}

const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_2::Get_RtsSshRequest() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

void RtsConnection_2::Set_RtsSshRequest(const Anki::Vector::ExternalComms::RtsSshRequest& new_RtsSshRequest)
{
  if(this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = new_RtsSshRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(new_RtsSshRequest);
    _tag = Tag::RtsSshRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsSshRequest>() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsSshRequest>(Anki::Vector::ExternalComms::RtsSshRequest member)
{
  return CreateRtsSshRequest(std::move(member));
}

void RtsConnection_2::Set_RtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  if (this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = std::move(new_RtsSshRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
    _tag = Tag::RtsSshRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  RtsConnection_2 m;
  m.Set_RtsSshResponse(new_RtsSshResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
  _tag = Tag::RtsSshResponse;
}

const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_2::Get_RtsSshResponse() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

void RtsConnection_2::Set_RtsSshResponse(const Anki::Vector::ExternalComms::RtsSshResponse& new_RtsSshResponse)
{
  if(this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = new_RtsSshResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(new_RtsSshResponse);
    _tag = Tag::RtsSshResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsSshResponse>() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsSshResponse>(Anki::Vector::ExternalComms::RtsSshResponse member)
{
  return CreateRtsSshResponse(std::move(member));
}

void RtsConnection_2::Set_RtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  if (this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = std::move(new_RtsSshResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
    _tag = Tag::RtsSshResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  RtsConnection_2 m;
  m.Set_RtsOtaCancelRequest(new_RtsOtaCancelRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
  _tag = Tag::RtsOtaCancelRequest;
}

const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_2::Get_RtsOtaCancelRequest() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

void RtsConnection_2::Set_RtsOtaCancelRequest(const Anki::Vector::ExternalComms::RtsOtaCancelRequest& new_RtsOtaCancelRequest)
{
  if(this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = new_RtsOtaCancelRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(new_RtsOtaCancelRequest);
    _tag = Tag::RtsOtaCancelRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsOtaCancelRequest>() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsOtaCancelRequest>(Anki::Vector::ExternalComms::RtsOtaCancelRequest member)
{
  return CreateRtsOtaCancelRequest(std::move(member));
}

void RtsConnection_2::Set_RtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  if (this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = std::move(new_RtsOtaCancelRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
    _tag = Tag::RtsOtaCancelRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  RtsConnection_2 m;
  m.Set_RtsLogRequest(new_RtsLogRequest);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
  _tag = Tag::RtsLogRequest;
}

const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_2::Get_RtsLogRequest() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

void RtsConnection_2::Set_RtsLogRequest(const Anki::Vector::ExternalComms::RtsLogRequest& new_RtsLogRequest)
{
  if(this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = new_RtsLogRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(new_RtsLogRequest);
    _tag = Tag::RtsLogRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsLogRequest>() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsLogRequest>(Anki::Vector::ExternalComms::RtsLogRequest member)
{
  return CreateRtsLogRequest(std::move(member));
}

void RtsConnection_2::Set_RtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  if (this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = std::move(new_RtsLogRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
    _tag = Tag::RtsLogRequest;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  RtsConnection_2 m;
  m.Set_RtsLogResponse(new_RtsLogResponse);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
  _tag = Tag::RtsLogResponse;
}

const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_2::Get_RtsLogResponse() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

void RtsConnection_2::Set_RtsLogResponse(const Anki::Vector::ExternalComms::RtsLogResponse& new_RtsLogResponse)
{
  if(this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = new_RtsLogResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(new_RtsLogResponse);
    _tag = Tag::RtsLogResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsLogResponse>() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsLogResponse>(Anki::Vector::ExternalComms::RtsLogResponse member)
{
  return CreateRtsLogResponse(std::move(member));
}

void RtsConnection_2::Set_RtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  if (this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = std::move(new_RtsLogResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
    _tag = Tag::RtsLogResponse;
  }
}

RtsConnection_2 RtsConnection_2::CreateRtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  RtsConnection_2 m;
  m.Set_RtsFileDownload(new_RtsFileDownload);
  return m;
}

RtsConnection_2::RtsConnection_2(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
  _tag = Tag::RtsFileDownload;
}

const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_2::Get_RtsFileDownload() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

void RtsConnection_2::Set_RtsFileDownload(const Anki::Vector::ExternalComms::RtsFileDownload& new_RtsFileDownload)
{
  if(this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = new_RtsFileDownload;
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(new_RtsFileDownload);
    _tag = Tag::RtsFileDownload;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_2::Get_<RtsConnection_2::Tag::RtsFileDownload>() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

template<>
RtsConnection_2 RtsConnection_2::Create_<RtsConnection_2::Tag::RtsFileDownload>(Anki::Vector::ExternalComms::RtsFileDownload member)
{
  return CreateRtsFileDownload(std::move(member));
}

void RtsConnection_2::Set_RtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  if (this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = std::move(new_RtsFileDownload);
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
    _tag = Tag::RtsFileDownload;
  }
}

size_t RtsConnection_2::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection_2::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(buffer);
    }
    else {
      this->_RtsConnRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsConnResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(buffer);
    }
    else {
      this->_RtsConnResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsNonceMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(buffer);
    }
    else {
      this->_RtsNonceMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(buffer);
    }
    else {
      this->_RtsChallengeMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeSuccessMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(buffer);
    }
    else {
      this->_RtsChallengeSuccessMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(buffer);
    }
    else {
      this->_RtsWifiConnectRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(buffer);
    }
    else {
      this->_RtsWifiConnectResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(buffer);
    }
    else {
      this->_RtsWifiIpRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(buffer);
    }
    else {
      this->_RtsWifiIpResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(buffer);
    }
    else {
      this->_RtsStatusRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusResponse_2:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusResponse_2)) Anki::Vector::ExternalComms::RtsStatusResponse_2(buffer);
    }
    else {
      this->_RtsStatusResponse_2.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(buffer);
    }
    else {
      this->_RtsWifiScanRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanResponse_2:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanResponse_2)) Anki::Vector::ExternalComms::RtsWifiScanResponse_2(buffer);
    }
    else {
      this->_RtsWifiScanResponse_2.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(buffer);
    }
    else {
      this->_RtsOtaUpdateRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(buffer);
    }
    else {
      this->_RtsOtaUpdateResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCancelPairing:
    if (newTag != oldTag) {
      new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(buffer);
    }
    else {
      this->_RtsCancelPairing.Unpack(buffer);
    }
    break;
  case Tag::RtsForceDisconnect:
    if (newTag != oldTag) {
      new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(buffer);
    }
    else {
      this->_RtsForceDisconnect.Unpack(buffer);
    }
    break;
  case Tag::RtsAck:
    if (newTag != oldTag) {
      new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(buffer);
    }
    else {
      this->_RtsAck.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(buffer);
    }
    else {
      this->_RtsWifiAccessPointRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(buffer);
    }
    else {
      this->_RtsWifiAccessPointResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSshRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(buffer);
    }
    else {
      this->_RtsSshRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSshResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(buffer);
    }
    else {
      this->_RtsSshResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaCancelRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(buffer);
    }
    else {
      this->_RtsOtaCancelRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(buffer);
    }
    else {
      this->_RtsLogRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(buffer);
    }
    else {
      this->_RtsLogResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsFileDownload:
    if (newTag != oldTag) {
      new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(buffer);
    }
    else {
      this->_RtsFileDownload.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection_2::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection_2::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnRequest:
    this->_RtsConnRequest.Pack(buffer);
    break;
  case Tag::RtsConnResponse:
    this->_RtsConnResponse.Pack(buffer);
    break;
  case Tag::RtsNonceMessage:
    this->_RtsNonceMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeMessage:
    this->_RtsChallengeMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeSuccessMessage:
    this->_RtsChallengeSuccessMessage.Pack(buffer);
    break;
  case Tag::RtsWifiConnectRequest:
    this->_RtsWifiConnectRequest.Pack(buffer);
    break;
  case Tag::RtsWifiConnectResponse:
    this->_RtsWifiConnectResponse.Pack(buffer);
    break;
  case Tag::RtsWifiIpRequest:
    this->_RtsWifiIpRequest.Pack(buffer);
    break;
  case Tag::RtsWifiIpResponse:
    this->_RtsWifiIpResponse.Pack(buffer);
    break;
  case Tag::RtsStatusRequest:
    this->_RtsStatusRequest.Pack(buffer);
    break;
  case Tag::RtsStatusResponse_2:
    this->_RtsStatusResponse_2.Pack(buffer);
    break;
  case Tag::RtsWifiScanRequest:
    this->_RtsWifiScanRequest.Pack(buffer);
    break;
  case Tag::RtsWifiScanResponse_2:
    this->_RtsWifiScanResponse_2.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateRequest:
    this->_RtsOtaUpdateRequest.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateResponse:
    this->_RtsOtaUpdateResponse.Pack(buffer);
    break;
  case Tag::RtsCancelPairing:
    this->_RtsCancelPairing.Pack(buffer);
    break;
  case Tag::RtsForceDisconnect:
    this->_RtsForceDisconnect.Pack(buffer);
    break;
  case Tag::RtsAck:
    this->_RtsAck.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointRequest:
    this->_RtsWifiAccessPointRequest.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointResponse:
    this->_RtsWifiAccessPointResponse.Pack(buffer);
    break;
  case Tag::RtsSshRequest:
    this->_RtsSshRequest.Pack(buffer);
    break;
  case Tag::RtsSshResponse:
    this->_RtsSshResponse.Pack(buffer);
    break;
  case Tag::RtsOtaCancelRequest:
    this->_RtsOtaCancelRequest.Pack(buffer);
    break;
  case Tag::RtsLogRequest:
    this->_RtsLogRequest.Pack(buffer);
    break;
  case Tag::RtsLogResponse:
    this->_RtsLogResponse.Pack(buffer);
    break;
  case Tag::RtsFileDownload:
    this->_RtsFileDownload.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection_2::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnRequest:
    result += this->_RtsConnRequest.Size(); // RtsConnRequest
    break;
  case Tag::RtsConnResponse:
    result += this->_RtsConnResponse.Size(); // RtsConnResponse
    break;
  case Tag::RtsNonceMessage:
    result += this->_RtsNonceMessage.Size(); // RtsNonceMessage
    break;
  case Tag::RtsChallengeMessage:
    result += this->_RtsChallengeMessage.Size(); // RtsChallengeMessage
    break;
  case Tag::RtsChallengeSuccessMessage:
    result += this->_RtsChallengeSuccessMessage.Size(); // RtsChallengeSuccessMessage
    break;
  case Tag::RtsWifiConnectRequest:
    result += this->_RtsWifiConnectRequest.Size(); // RtsWifiConnectRequest
    break;
  case Tag::RtsWifiConnectResponse:
    result += this->_RtsWifiConnectResponse.Size(); // RtsWifiConnectResponse
    break;
  case Tag::RtsWifiIpRequest:
    result += this->_RtsWifiIpRequest.Size(); // RtsWifiIpRequest
    break;
  case Tag::RtsWifiIpResponse:
    result += this->_RtsWifiIpResponse.Size(); // RtsWifiIpResponse
    break;
  case Tag::RtsStatusRequest:
    result += this->_RtsStatusRequest.Size(); // RtsStatusRequest
    break;
  case Tag::RtsStatusResponse_2:
    result += this->_RtsStatusResponse_2.Size(); // RtsStatusResponse_2
    break;
  case Tag::RtsWifiScanRequest:
    result += this->_RtsWifiScanRequest.Size(); // RtsWifiScanRequest
    break;
  case Tag::RtsWifiScanResponse_2:
    result += this->_RtsWifiScanResponse_2.Size(); // RtsWifiScanResponse_2
    break;
  case Tag::RtsOtaUpdateRequest:
    result += this->_RtsOtaUpdateRequest.Size(); // RtsOtaUpdateRequest
    break;
  case Tag::RtsOtaUpdateResponse:
    result += this->_RtsOtaUpdateResponse.Size(); // RtsOtaUpdateResponse
    break;
  case Tag::RtsCancelPairing:
    result += this->_RtsCancelPairing.Size(); // RtsCancelPairing
    break;
  case Tag::RtsForceDisconnect:
    result += this->_RtsForceDisconnect.Size(); // RtsForceDisconnect
    break;
  case Tag::RtsAck:
    result += this->_RtsAck.Size(); // RtsAck
    break;
  case Tag::RtsWifiAccessPointRequest:
    result += this->_RtsWifiAccessPointRequest.Size(); // RtsWifiAccessPointRequest
    break;
  case Tag::RtsWifiAccessPointResponse:
    result += this->_RtsWifiAccessPointResponse.Size(); // RtsWifiAccessPointResponse
    break;
  case Tag::RtsSshRequest:
    result += this->_RtsSshRequest.Size(); // RtsSshRequest
    break;
  case Tag::RtsSshResponse:
    result += this->_RtsSshResponse.Size(); // RtsSshResponse
    break;
  case Tag::RtsOtaCancelRequest:
    result += this->_RtsOtaCancelRequest.Size(); // RtsOtaCancelRequest
    break;
  case Tag::RtsLogRequest:
    result += this->_RtsLogRequest.Size(); // RtsLogRequest
    break;
  case Tag::RtsLogResponse:
    result += this->_RtsLogResponse.Size(); // RtsLogResponse
    break;
  case Tag::RtsFileDownload:
    result += this->_RtsFileDownload.Size(); // RtsFileDownload
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection_2::operator==(const RtsConnection_2& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnRequest:
    return this->_RtsConnRequest == other._RtsConnRequest;
  case Tag::RtsConnResponse:
    return this->_RtsConnResponse == other._RtsConnResponse;
  case Tag::RtsNonceMessage:
    return this->_RtsNonceMessage == other._RtsNonceMessage;
  case Tag::RtsChallengeMessage:
    return this->_RtsChallengeMessage == other._RtsChallengeMessage;
  case Tag::RtsChallengeSuccessMessage:
    return this->_RtsChallengeSuccessMessage == other._RtsChallengeSuccessMessage;
  case Tag::RtsWifiConnectRequest:
    return this->_RtsWifiConnectRequest == other._RtsWifiConnectRequest;
  case Tag::RtsWifiConnectResponse:
    return this->_RtsWifiConnectResponse == other._RtsWifiConnectResponse;
  case Tag::RtsWifiIpRequest:
    return this->_RtsWifiIpRequest == other._RtsWifiIpRequest;
  case Tag::RtsWifiIpResponse:
    return this->_RtsWifiIpResponse == other._RtsWifiIpResponse;
  case Tag::RtsStatusRequest:
    return this->_RtsStatusRequest == other._RtsStatusRequest;
  case Tag::RtsStatusResponse_2:
    return this->_RtsStatusResponse_2 == other._RtsStatusResponse_2;
  case Tag::RtsWifiScanRequest:
    return this->_RtsWifiScanRequest == other._RtsWifiScanRequest;
  case Tag::RtsWifiScanResponse_2:
    return this->_RtsWifiScanResponse_2 == other._RtsWifiScanResponse_2;
  case Tag::RtsOtaUpdateRequest:
    return this->_RtsOtaUpdateRequest == other._RtsOtaUpdateRequest;
  case Tag::RtsOtaUpdateResponse:
    return this->_RtsOtaUpdateResponse == other._RtsOtaUpdateResponse;
  case Tag::RtsCancelPairing:
    return this->_RtsCancelPairing == other._RtsCancelPairing;
  case Tag::RtsForceDisconnect:
    return this->_RtsForceDisconnect == other._RtsForceDisconnect;
  case Tag::RtsAck:
    return this->_RtsAck == other._RtsAck;
  case Tag::RtsWifiAccessPointRequest:
    return this->_RtsWifiAccessPointRequest == other._RtsWifiAccessPointRequest;
  case Tag::RtsWifiAccessPointResponse:
    return this->_RtsWifiAccessPointResponse == other._RtsWifiAccessPointResponse;
  case Tag::RtsSshRequest:
    return this->_RtsSshRequest == other._RtsSshRequest;
  case Tag::RtsSshResponse:
    return this->_RtsSshResponse == other._RtsSshResponse;
  case Tag::RtsOtaCancelRequest:
    return this->_RtsOtaCancelRequest == other._RtsOtaCancelRequest;
  case Tag::RtsLogRequest:
    return this->_RtsLogRequest == other._RtsLogRequest;
  case Tag::RtsLogResponse:
    return this->_RtsLogResponse == other._RtsLogResponse;
  case Tag::RtsFileDownload:
    return this->_RtsFileDownload == other._RtsFileDownload;
  default:
    return true;
  }
}

bool RtsConnection_2::operator!=(const RtsConnection_2& other) const
{
  return !(operator==(other));
}

void RtsConnection_2::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnRequest:
    _RtsConnRequest.~RtsConnRequest();
    break;
  case Tag::RtsConnResponse:
    _RtsConnResponse.~RtsConnResponse();
    break;
  case Tag::RtsNonceMessage:
    _RtsNonceMessage.~RtsNonceMessage();
    break;
  case Tag::RtsChallengeMessage:
    _RtsChallengeMessage.~RtsChallengeMessage();
    break;
  case Tag::RtsChallengeSuccessMessage:
    _RtsChallengeSuccessMessage.~RtsChallengeSuccessMessage();
    break;
  case Tag::RtsWifiConnectRequest:
    _RtsWifiConnectRequest.~RtsWifiConnectRequest();
    break;
  case Tag::RtsWifiConnectResponse:
    _RtsWifiConnectResponse.~RtsWifiConnectResponse();
    break;
  case Tag::RtsWifiIpRequest:
    _RtsWifiIpRequest.~RtsWifiIpRequest();
    break;
  case Tag::RtsWifiIpResponse:
    _RtsWifiIpResponse.~RtsWifiIpResponse();
    break;
  case Tag::RtsStatusRequest:
    _RtsStatusRequest.~RtsStatusRequest();
    break;
  case Tag::RtsStatusResponse_2:
    _RtsStatusResponse_2.~RtsStatusResponse_2();
    break;
  case Tag::RtsWifiScanRequest:
    _RtsWifiScanRequest.~RtsWifiScanRequest();
    break;
  case Tag::RtsWifiScanResponse_2:
    _RtsWifiScanResponse_2.~RtsWifiScanResponse_2();
    break;
  case Tag::RtsOtaUpdateRequest:
    _RtsOtaUpdateRequest.~RtsOtaUpdateRequest();
    break;
  case Tag::RtsOtaUpdateResponse:
    _RtsOtaUpdateResponse.~RtsOtaUpdateResponse();
    break;
  case Tag::RtsCancelPairing:
    _RtsCancelPairing.~RtsCancelPairing();
    break;
  case Tag::RtsForceDisconnect:
    _RtsForceDisconnect.~RtsForceDisconnect();
    break;
  case Tag::RtsAck:
    _RtsAck.~RtsAck();
    break;
  case Tag::RtsWifiAccessPointRequest:
    _RtsWifiAccessPointRequest.~RtsWifiAccessPointRequest();
    break;
  case Tag::RtsWifiAccessPointResponse:
    _RtsWifiAccessPointResponse.~RtsWifiAccessPointResponse();
    break;
  case Tag::RtsSshRequest:
    _RtsSshRequest.~RtsSshRequest();
    break;
  case Tag::RtsSshResponse:
    _RtsSshResponse.~RtsSshResponse();
    break;
  case Tag::RtsOtaCancelRequest:
    _RtsOtaCancelRequest.~RtsOtaCancelRequest();
    break;
  case Tag::RtsLogRequest:
    _RtsLogRequest.~RtsLogRequest();
    break;
  case Tag::RtsLogResponse:
    _RtsLogResponse.~RtsLogResponse();
    break;
  case Tag::RtsFileDownload:
    _RtsFileDownload.~RtsFileDownload();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnection_2TagToString(const RtsConnection_2Tag tag) {
  switch(tag) {
  case RtsConnection_2Tag::Error:
    return "Error";
  case RtsConnection_2Tag::RtsConnRequest:
    return "RtsConnRequest";
  case RtsConnection_2Tag::RtsConnResponse:
    return "RtsConnResponse";
  case RtsConnection_2Tag::RtsNonceMessage:
    return "RtsNonceMessage";
  case RtsConnection_2Tag::RtsChallengeMessage:
    return "RtsChallengeMessage";
  case RtsConnection_2Tag::RtsChallengeSuccessMessage:
    return "RtsChallengeSuccessMessage";
  case RtsConnection_2Tag::RtsWifiConnectRequest:
    return "RtsWifiConnectRequest";
  case RtsConnection_2Tag::RtsWifiConnectResponse:
    return "RtsWifiConnectResponse";
  case RtsConnection_2Tag::RtsWifiIpRequest:
    return "RtsWifiIpRequest";
  case RtsConnection_2Tag::RtsWifiIpResponse:
    return "RtsWifiIpResponse";
  case RtsConnection_2Tag::RtsStatusRequest:
    return "RtsStatusRequest";
  case RtsConnection_2Tag::RtsStatusResponse_2:
    return "RtsStatusResponse_2";
  case RtsConnection_2Tag::RtsWifiScanRequest:
    return "RtsWifiScanRequest";
  case RtsConnection_2Tag::RtsWifiScanResponse_2:
    return "RtsWifiScanResponse_2";
  case RtsConnection_2Tag::RtsOtaUpdateRequest:
    return "RtsOtaUpdateRequest";
  case RtsConnection_2Tag::RtsOtaUpdateResponse:
    return "RtsOtaUpdateResponse";
  case RtsConnection_2Tag::RtsCancelPairing:
    return "RtsCancelPairing";
  case RtsConnection_2Tag::RtsForceDisconnect:
    return "RtsForceDisconnect";
  case RtsConnection_2Tag::RtsAck:
    return "RtsAck";
  case RtsConnection_2Tag::RtsWifiAccessPointRequest:
    return "RtsWifiAccessPointRequest";
  case RtsConnection_2Tag::RtsWifiAccessPointResponse:
    return "RtsWifiAccessPointResponse";
  case RtsConnection_2Tag::RtsSshRequest:
    return "RtsSshRequest";
  case RtsConnection_2Tag::RtsSshResponse:
    return "RtsSshResponse";
  case RtsConnection_2Tag::RtsOtaCancelRequest:
    return "RtsOtaCancelRequest";
  case RtsConnection_2Tag::RtsLogRequest:
    return "RtsLogRequest";
  case RtsConnection_2Tag::RtsLogResponse:
    return "RtsLogResponse";
  case RtsConnection_2Tag::RtsFileDownload:
    return "RtsFileDownload";
  default:
    return "INVALID";
  }
}

const char* RtsConnection_2VersionHashStr = "8f8aef23dd10d02ae39567d8617bcc5c";

const uint8_t RtsConnection_2VersionHash[16] = { 
    0x8f, 0x8a, 0xef, 0x23, 0xdd, 0x10, 0xd0, 0x2a, 0xe3, 0x95, 0x67, 0xd8, 0x61, 0x7b, 0xcc, 0x5c 
};

// UNION RtsConnection_3

RtsConnection_3::RtsConnection_3(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection_3::RtsConnection_3(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection_3::RtsConnection_3(const RtsConnection_3& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_3:
    new(&(this->_RtsStatusResponse_3)) Anki::Vector::ExternalComms::RtsStatusResponse_3(other._RtsStatusResponse_3);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(other._RtsCloudSessionRequest);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection_3::RtsConnection_3(RtsConnection_3&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_3:
    new(&(this->_RtsStatusResponse_3)) Anki::Vector::ExternalComms::RtsStatusResponse_3(std::move(other._RtsStatusResponse_3));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(other._RtsCloudSessionRequest));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection_3& RtsConnection_3::operator=(const RtsConnection_3& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_3:
    new(&(this->_RtsStatusResponse_3)) Anki::Vector::ExternalComms::RtsStatusResponse_3(other._RtsStatusResponse_3);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(other._RtsCloudSessionRequest);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection_3& RtsConnection_3::operator=(RtsConnection_3&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_3:
    new(&(this->_RtsStatusResponse_3)) Anki::Vector::ExternalComms::RtsStatusResponse_3(std::move(other._RtsStatusResponse_3));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(other._RtsCloudSessionRequest));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection_3 RtsConnection_3::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection_3 m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection_3::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection_3::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection_3::Get_<RtsConnection_3::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection_3::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  RtsConnection_3 m;
  m.Set_RtsConnRequest(new_RtsConnRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
  _tag = Tag::RtsConnRequest;
}

const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_3::Get_RtsConnRequest() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

void RtsConnection_3::Set_RtsConnRequest(const Anki::Vector::ExternalComms::RtsConnRequest& new_RtsConnRequest)
{
  if(this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = new_RtsConnRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(new_RtsConnRequest);
    _tag = Tag::RtsConnRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsConnRequest>() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsConnRequest>(Anki::Vector::ExternalComms::RtsConnRequest member)
{
  return CreateRtsConnRequest(std::move(member));
}

void RtsConnection_3::Set_RtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  if (this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = std::move(new_RtsConnRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
    _tag = Tag::RtsConnRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  RtsConnection_3 m;
  m.Set_RtsConnResponse(new_RtsConnResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
  _tag = Tag::RtsConnResponse;
}

const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_3::Get_RtsConnResponse() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

void RtsConnection_3::Set_RtsConnResponse(const Anki::Vector::ExternalComms::RtsConnResponse& new_RtsConnResponse)
{
  if(this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = new_RtsConnResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(new_RtsConnResponse);
    _tag = Tag::RtsConnResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsConnResponse>() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsConnResponse>(Anki::Vector::ExternalComms::RtsConnResponse member)
{
  return CreateRtsConnResponse(std::move(member));
}

void RtsConnection_3::Set_RtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  if (this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = std::move(new_RtsConnResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
    _tag = Tag::RtsConnResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  RtsConnection_3 m;
  m.Set_RtsNonceMessage(new_RtsNonceMessage);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
  _tag = Tag::RtsNonceMessage;
}

const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_3::Get_RtsNonceMessage() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

void RtsConnection_3::Set_RtsNonceMessage(const Anki::Vector::ExternalComms::RtsNonceMessage& new_RtsNonceMessage)
{
  if(this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = new_RtsNonceMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(new_RtsNonceMessage);
    _tag = Tag::RtsNonceMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsNonceMessage>() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsNonceMessage>(Anki::Vector::ExternalComms::RtsNonceMessage member)
{
  return CreateRtsNonceMessage(std::move(member));
}

void RtsConnection_3::Set_RtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  if (this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = std::move(new_RtsNonceMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
    _tag = Tag::RtsNonceMessage;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  RtsConnection_3 m;
  m.Set_RtsChallengeMessage(new_RtsChallengeMessage);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
  _tag = Tag::RtsChallengeMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_3::Get_RtsChallengeMessage() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

void RtsConnection_3::Set_RtsChallengeMessage(const Anki::Vector::ExternalComms::RtsChallengeMessage& new_RtsChallengeMessage)
{
  if(this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = new_RtsChallengeMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(new_RtsChallengeMessage);
    _tag = Tag::RtsChallengeMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsChallengeMessage>() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsChallengeMessage>(Anki::Vector::ExternalComms::RtsChallengeMessage member)
{
  return CreateRtsChallengeMessage(std::move(member));
}

void RtsConnection_3::Set_RtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  if (this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = std::move(new_RtsChallengeMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
    _tag = Tag::RtsChallengeMessage;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  RtsConnection_3 m;
  m.Set_RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
  _tag = Tag::RtsChallengeSuccessMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_3::Get_RtsChallengeSuccessMessage() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

void RtsConnection_3::Set_RtsChallengeSuccessMessage(const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& new_RtsChallengeSuccessMessage)
{
  if(this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = new_RtsChallengeSuccessMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsChallengeSuccessMessage>() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsChallengeSuccessMessage>(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage member)
{
  return CreateRtsChallengeSuccessMessage(std::move(member));
}

void RtsConnection_3::Set_RtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  if (this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = std::move(new_RtsChallengeSuccessMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  RtsConnection_3 m;
  m.Set_RtsWifiConnectRequest(new_RtsWifiConnectRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
  _tag = Tag::RtsWifiConnectRequest;
}

const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_3::Get_RtsWifiConnectRequest() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

void RtsConnection_3::Set_RtsWifiConnectRequest(const Anki::Vector::ExternalComms::RtsWifiConnectRequest& new_RtsWifiConnectRequest)
{
  if(this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = new_RtsWifiConnectRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(new_RtsWifiConnectRequest);
    _tag = Tag::RtsWifiConnectRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiConnectRequest>() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiConnectRequest>(Anki::Vector::ExternalComms::RtsWifiConnectRequest member)
{
  return CreateRtsWifiConnectRequest(std::move(member));
}

void RtsConnection_3::Set_RtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  if (this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = std::move(new_RtsWifiConnectRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
    _tag = Tag::RtsWifiConnectRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  RtsConnection_3 m;
  m.Set_RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
  _tag = Tag::RtsWifiConnectResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_3::Get_RtsWifiConnectResponse_3() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

void RtsConnection_3::Set_RtsWifiConnectResponse_3(const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& new_RtsWifiConnectResponse_3)
{
  if(this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = new_RtsWifiConnectResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiConnectResponse_3>() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiConnectResponse_3>(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3 member)
{
  return CreateRtsWifiConnectResponse_3(std::move(member));
}

void RtsConnection_3::Set_RtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  if (this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = std::move(new_RtsWifiConnectResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  RtsConnection_3 m;
  m.Set_RtsWifiIpRequest(new_RtsWifiIpRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
  _tag = Tag::RtsWifiIpRequest;
}

const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_3::Get_RtsWifiIpRequest() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

void RtsConnection_3::Set_RtsWifiIpRequest(const Anki::Vector::ExternalComms::RtsWifiIpRequest& new_RtsWifiIpRequest)
{
  if(this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = new_RtsWifiIpRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(new_RtsWifiIpRequest);
    _tag = Tag::RtsWifiIpRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiIpRequest>() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiIpRequest>(Anki::Vector::ExternalComms::RtsWifiIpRequest member)
{
  return CreateRtsWifiIpRequest(std::move(member));
}

void RtsConnection_3::Set_RtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  if (this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = std::move(new_RtsWifiIpRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
    _tag = Tag::RtsWifiIpRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  RtsConnection_3 m;
  m.Set_RtsWifiIpResponse(new_RtsWifiIpResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
  _tag = Tag::RtsWifiIpResponse;
}

const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_3::Get_RtsWifiIpResponse() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

void RtsConnection_3::Set_RtsWifiIpResponse(const Anki::Vector::ExternalComms::RtsWifiIpResponse& new_RtsWifiIpResponse)
{
  if(this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = new_RtsWifiIpResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(new_RtsWifiIpResponse);
    _tag = Tag::RtsWifiIpResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiIpResponse>() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiIpResponse>(Anki::Vector::ExternalComms::RtsWifiIpResponse member)
{
  return CreateRtsWifiIpResponse(std::move(member));
}

void RtsConnection_3::Set_RtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  if (this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = std::move(new_RtsWifiIpResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
    _tag = Tag::RtsWifiIpResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  RtsConnection_3 m;
  m.Set_RtsStatusRequest(new_RtsStatusRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
  _tag = Tag::RtsStatusRequest;
}

const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_3::Get_RtsStatusRequest() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

void RtsConnection_3::Set_RtsStatusRequest(const Anki::Vector::ExternalComms::RtsStatusRequest& new_RtsStatusRequest)
{
  if(this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = new_RtsStatusRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(new_RtsStatusRequest);
    _tag = Tag::RtsStatusRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsStatusRequest>() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsStatusRequest>(Anki::Vector::ExternalComms::RtsStatusRequest member)
{
  return CreateRtsStatusRequest(std::move(member));
}

void RtsConnection_3::Set_RtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  if (this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = std::move(new_RtsStatusRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
    _tag = Tag::RtsStatusRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsStatusResponse_3(Anki::Vector::ExternalComms::RtsStatusResponse_3&& new_RtsStatusResponse_3)
{
  RtsConnection_3 m;
  m.Set_RtsStatusResponse_3(new_RtsStatusResponse_3);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsStatusResponse_3&& new_RtsStatusResponse_3)
{
  new(&this->_RtsStatusResponse_3) Anki::Vector::ExternalComms::RtsStatusResponse_3(std::move(new_RtsStatusResponse_3));
  _tag = Tag::RtsStatusResponse_3;
}

const Anki::Vector::ExternalComms::RtsStatusResponse_3& RtsConnection_3::Get_RtsStatusResponse_3() const
{
  assert(_tag == Tag::RtsStatusResponse_3);
  return this->_RtsStatusResponse_3;
}

void RtsConnection_3::Set_RtsStatusResponse_3(const Anki::Vector::ExternalComms::RtsStatusResponse_3& new_RtsStatusResponse_3)
{
  if(this->_tag == Tag::RtsStatusResponse_3) {
    this->_RtsStatusResponse_3 = new_RtsStatusResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_3) Anki::Vector::ExternalComms::RtsStatusResponse_3(new_RtsStatusResponse_3);
    _tag = Tag::RtsStatusResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusResponse_3& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsStatusResponse_3>() const
{
  assert(_tag == Tag::RtsStatusResponse_3);
  return this->_RtsStatusResponse_3;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsStatusResponse_3>(Anki::Vector::ExternalComms::RtsStatusResponse_3 member)
{
  return CreateRtsStatusResponse_3(std::move(member));
}

void RtsConnection_3::Set_RtsStatusResponse_3(Anki::Vector::ExternalComms::RtsStatusResponse_3&& new_RtsStatusResponse_3)
{
  if (this->_tag == Tag::RtsStatusResponse_3) {
    this->_RtsStatusResponse_3 = std::move(new_RtsStatusResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_3) Anki::Vector::ExternalComms::RtsStatusResponse_3(std::move(new_RtsStatusResponse_3));
    _tag = Tag::RtsStatusResponse_3;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  RtsConnection_3 m;
  m.Set_RtsWifiScanRequest(new_RtsWifiScanRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
  _tag = Tag::RtsWifiScanRequest;
}

const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_3::Get_RtsWifiScanRequest() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

void RtsConnection_3::Set_RtsWifiScanRequest(const Anki::Vector::ExternalComms::RtsWifiScanRequest& new_RtsWifiScanRequest)
{
  if(this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = new_RtsWifiScanRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(new_RtsWifiScanRequest);
    _tag = Tag::RtsWifiScanRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiScanRequest>() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiScanRequest>(Anki::Vector::ExternalComms::RtsWifiScanRequest member)
{
  return CreateRtsWifiScanRequest(std::move(member));
}

void RtsConnection_3::Set_RtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  if (this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = std::move(new_RtsWifiScanRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
    _tag = Tag::RtsWifiScanRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  RtsConnection_3 m;
  m.Set_RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
  _tag = Tag::RtsWifiScanResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_3::Get_RtsWifiScanResponse_3() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

void RtsConnection_3::Set_RtsWifiScanResponse_3(const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& new_RtsWifiScanResponse_3)
{
  if(this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = new_RtsWifiScanResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiScanResponse_3>() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiScanResponse_3>(Anki::Vector::ExternalComms::RtsWifiScanResponse_3 member)
{
  return CreateRtsWifiScanResponse_3(std::move(member));
}

void RtsConnection_3::Set_RtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  if (this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = std::move(new_RtsWifiScanResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  RtsConnection_3 m;
  m.Set_RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
  _tag = Tag::RtsOtaUpdateRequest;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_3::Get_RtsOtaUpdateRequest() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

void RtsConnection_3::Set_RtsOtaUpdateRequest(const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& new_RtsOtaUpdateRequest)
{
  if(this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = new_RtsOtaUpdateRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsOtaUpdateRequest>() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsOtaUpdateRequest>(Anki::Vector::ExternalComms::RtsOtaUpdateRequest member)
{
  return CreateRtsOtaUpdateRequest(std::move(member));
}

void RtsConnection_3::Set_RtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  if (this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = std::move(new_RtsOtaUpdateRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  RtsConnection_3 m;
  m.Set_RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
  _tag = Tag::RtsOtaUpdateResponse;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_3::Get_RtsOtaUpdateResponse() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

void RtsConnection_3::Set_RtsOtaUpdateResponse(const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& new_RtsOtaUpdateResponse)
{
  if(this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = new_RtsOtaUpdateResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsOtaUpdateResponse>() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsOtaUpdateResponse>(Anki::Vector::ExternalComms::RtsOtaUpdateResponse member)
{
  return CreateRtsOtaUpdateResponse(std::move(member));
}

void RtsConnection_3::Set_RtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  if (this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = std::move(new_RtsOtaUpdateResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  RtsConnection_3 m;
  m.Set_RtsCancelPairing(new_RtsCancelPairing);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
  _tag = Tag::RtsCancelPairing;
}

const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_3::Get_RtsCancelPairing() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

void RtsConnection_3::Set_RtsCancelPairing(const Anki::Vector::ExternalComms::RtsCancelPairing& new_RtsCancelPairing)
{
  if(this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = new_RtsCancelPairing;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(new_RtsCancelPairing);
    _tag = Tag::RtsCancelPairing;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsCancelPairing>() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsCancelPairing>(Anki::Vector::ExternalComms::RtsCancelPairing member)
{
  return CreateRtsCancelPairing(std::move(member));
}

void RtsConnection_3::Set_RtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  if (this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = std::move(new_RtsCancelPairing);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
    _tag = Tag::RtsCancelPairing;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  RtsConnection_3 m;
  m.Set_RtsForceDisconnect(new_RtsForceDisconnect);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
  _tag = Tag::RtsForceDisconnect;
}

const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_3::Get_RtsForceDisconnect() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

void RtsConnection_3::Set_RtsForceDisconnect(const Anki::Vector::ExternalComms::RtsForceDisconnect& new_RtsForceDisconnect)
{
  if(this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = new_RtsForceDisconnect;
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(new_RtsForceDisconnect);
    _tag = Tag::RtsForceDisconnect;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsForceDisconnect>() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsForceDisconnect>(Anki::Vector::ExternalComms::RtsForceDisconnect member)
{
  return CreateRtsForceDisconnect(std::move(member));
}

void RtsConnection_3::Set_RtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  if (this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = std::move(new_RtsForceDisconnect);
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
    _tag = Tag::RtsForceDisconnect;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  RtsConnection_3 m;
  m.Set_RtsAck(new_RtsAck);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
  _tag = Tag::RtsAck;
}

const Anki::Vector::ExternalComms::RtsAck& RtsConnection_3::Get_RtsAck() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

void RtsConnection_3::Set_RtsAck(const Anki::Vector::ExternalComms::RtsAck& new_RtsAck)
{
  if(this->_tag == Tag::RtsAck) {
    this->_RtsAck = new_RtsAck;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(new_RtsAck);
    _tag = Tag::RtsAck;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAck& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsAck>() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsAck>(Anki::Vector::ExternalComms::RtsAck member)
{
  return CreateRtsAck(std::move(member));
}

void RtsConnection_3::Set_RtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  if (this->_tag == Tag::RtsAck) {
    this->_RtsAck = std::move(new_RtsAck);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
    _tag = Tag::RtsAck;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  RtsConnection_3 m;
  m.Set_RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
  _tag = Tag::RtsWifiAccessPointRequest;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_3::Get_RtsWifiAccessPointRequest() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

void RtsConnection_3::Set_RtsWifiAccessPointRequest(const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& new_RtsWifiAccessPointRequest)
{
  if(this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = new_RtsWifiAccessPointRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiAccessPointRequest>() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiAccessPointRequest>(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest member)
{
  return CreateRtsWifiAccessPointRequest(std::move(member));
}

void RtsConnection_3::Set_RtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  if (this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = std::move(new_RtsWifiAccessPointRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  RtsConnection_3 m;
  m.Set_RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
  _tag = Tag::RtsWifiAccessPointResponse;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_3::Get_RtsWifiAccessPointResponse() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

void RtsConnection_3::Set_RtsWifiAccessPointResponse(const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& new_RtsWifiAccessPointResponse)
{
  if(this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = new_RtsWifiAccessPointResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiAccessPointResponse>() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiAccessPointResponse>(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse member)
{
  return CreateRtsWifiAccessPointResponse(std::move(member));
}

void RtsConnection_3::Set_RtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  if (this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = std::move(new_RtsWifiAccessPointResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  RtsConnection_3 m;
  m.Set_RtsSshRequest(new_RtsSshRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
  _tag = Tag::RtsSshRequest;
}

const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_3::Get_RtsSshRequest() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

void RtsConnection_3::Set_RtsSshRequest(const Anki::Vector::ExternalComms::RtsSshRequest& new_RtsSshRequest)
{
  if(this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = new_RtsSshRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(new_RtsSshRequest);
    _tag = Tag::RtsSshRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsSshRequest>() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsSshRequest>(Anki::Vector::ExternalComms::RtsSshRequest member)
{
  return CreateRtsSshRequest(std::move(member));
}

void RtsConnection_3::Set_RtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  if (this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = std::move(new_RtsSshRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
    _tag = Tag::RtsSshRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  RtsConnection_3 m;
  m.Set_RtsSshResponse(new_RtsSshResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
  _tag = Tag::RtsSshResponse;
}

const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_3::Get_RtsSshResponse() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

void RtsConnection_3::Set_RtsSshResponse(const Anki::Vector::ExternalComms::RtsSshResponse& new_RtsSshResponse)
{
  if(this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = new_RtsSshResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(new_RtsSshResponse);
    _tag = Tag::RtsSshResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsSshResponse>() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsSshResponse>(Anki::Vector::ExternalComms::RtsSshResponse member)
{
  return CreateRtsSshResponse(std::move(member));
}

void RtsConnection_3::Set_RtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  if (this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = std::move(new_RtsSshResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
    _tag = Tag::RtsSshResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  RtsConnection_3 m;
  m.Set_RtsOtaCancelRequest(new_RtsOtaCancelRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
  _tag = Tag::RtsOtaCancelRequest;
}

const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_3::Get_RtsOtaCancelRequest() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

void RtsConnection_3::Set_RtsOtaCancelRequest(const Anki::Vector::ExternalComms::RtsOtaCancelRequest& new_RtsOtaCancelRequest)
{
  if(this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = new_RtsOtaCancelRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(new_RtsOtaCancelRequest);
    _tag = Tag::RtsOtaCancelRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsOtaCancelRequest>() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsOtaCancelRequest>(Anki::Vector::ExternalComms::RtsOtaCancelRequest member)
{
  return CreateRtsOtaCancelRequest(std::move(member));
}

void RtsConnection_3::Set_RtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  if (this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = std::move(new_RtsOtaCancelRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
    _tag = Tag::RtsOtaCancelRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  RtsConnection_3 m;
  m.Set_RtsLogRequest(new_RtsLogRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
  _tag = Tag::RtsLogRequest;
}

const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_3::Get_RtsLogRequest() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

void RtsConnection_3::Set_RtsLogRequest(const Anki::Vector::ExternalComms::RtsLogRequest& new_RtsLogRequest)
{
  if(this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = new_RtsLogRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(new_RtsLogRequest);
    _tag = Tag::RtsLogRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsLogRequest>() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsLogRequest>(Anki::Vector::ExternalComms::RtsLogRequest member)
{
  return CreateRtsLogRequest(std::move(member));
}

void RtsConnection_3::Set_RtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  if (this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = std::move(new_RtsLogRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
    _tag = Tag::RtsLogRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  RtsConnection_3 m;
  m.Set_RtsLogResponse(new_RtsLogResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
  _tag = Tag::RtsLogResponse;
}

const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_3::Get_RtsLogResponse() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

void RtsConnection_3::Set_RtsLogResponse(const Anki::Vector::ExternalComms::RtsLogResponse& new_RtsLogResponse)
{
  if(this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = new_RtsLogResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(new_RtsLogResponse);
    _tag = Tag::RtsLogResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsLogResponse>() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsLogResponse>(Anki::Vector::ExternalComms::RtsLogResponse member)
{
  return CreateRtsLogResponse(std::move(member));
}

void RtsConnection_3::Set_RtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  if (this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = std::move(new_RtsLogResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
    _tag = Tag::RtsLogResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  RtsConnection_3 m;
  m.Set_RtsFileDownload(new_RtsFileDownload);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
  _tag = Tag::RtsFileDownload;
}

const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_3::Get_RtsFileDownload() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

void RtsConnection_3::Set_RtsFileDownload(const Anki::Vector::ExternalComms::RtsFileDownload& new_RtsFileDownload)
{
  if(this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = new_RtsFileDownload;
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(new_RtsFileDownload);
    _tag = Tag::RtsFileDownload;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsFileDownload>() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsFileDownload>(Anki::Vector::ExternalComms::RtsFileDownload member)
{
  return CreateRtsFileDownload(std::move(member));
}

void RtsConnection_3::Set_RtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  if (this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = std::move(new_RtsFileDownload);
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
    _tag = Tag::RtsFileDownload;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  RtsConnection_3 m;
  m.Set_RtsWifiForgetRequest(new_RtsWifiForgetRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
  _tag = Tag::RtsWifiForgetRequest;
}

const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_3::Get_RtsWifiForgetRequest() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

void RtsConnection_3::Set_RtsWifiForgetRequest(const Anki::Vector::ExternalComms::RtsWifiForgetRequest& new_RtsWifiForgetRequest)
{
  if(this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = new_RtsWifiForgetRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(new_RtsWifiForgetRequest);
    _tag = Tag::RtsWifiForgetRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiForgetRequest>() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiForgetRequest>(Anki::Vector::ExternalComms::RtsWifiForgetRequest member)
{
  return CreateRtsWifiForgetRequest(std::move(member));
}

void RtsConnection_3::Set_RtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  if (this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = std::move(new_RtsWifiForgetRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
    _tag = Tag::RtsWifiForgetRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  RtsConnection_3 m;
  m.Set_RtsWifiForgetResponse(new_RtsWifiForgetResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
  _tag = Tag::RtsWifiForgetResponse;
}

const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_3::Get_RtsWifiForgetResponse() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

void RtsConnection_3::Set_RtsWifiForgetResponse(const Anki::Vector::ExternalComms::RtsWifiForgetResponse& new_RtsWifiForgetResponse)
{
  if(this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = new_RtsWifiForgetResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(new_RtsWifiForgetResponse);
    _tag = Tag::RtsWifiForgetResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsWifiForgetResponse>() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsWifiForgetResponse>(Anki::Vector::ExternalComms::RtsWifiForgetResponse member)
{
  return CreateRtsWifiForgetResponse(std::move(member));
}

void RtsConnection_3::Set_RtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  if (this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = std::move(new_RtsWifiForgetResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
    _tag = Tag::RtsWifiForgetResponse;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsCloudSessionRequest(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  RtsConnection_3 m;
  m.Set_RtsCloudSessionRequest(new_RtsCloudSessionRequest);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(new_RtsCloudSessionRequest));
  _tag = Tag::RtsCloudSessionRequest;
}

const Anki::Vector::ExternalComms::RtsCloudSessionRequest& RtsConnection_3::Get_RtsCloudSessionRequest() const
{
  assert(_tag == Tag::RtsCloudSessionRequest);
  return this->_RtsCloudSessionRequest;
}

void RtsConnection_3::Set_RtsCloudSessionRequest(const Anki::Vector::ExternalComms::RtsCloudSessionRequest& new_RtsCloudSessionRequest)
{
  if(this->_tag == Tag::RtsCloudSessionRequest) {
    this->_RtsCloudSessionRequest = new_RtsCloudSessionRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(new_RtsCloudSessionRequest);
    _tag = Tag::RtsCloudSessionRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionRequest& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsCloudSessionRequest>() const
{
  assert(_tag == Tag::RtsCloudSessionRequest);
  return this->_RtsCloudSessionRequest;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsCloudSessionRequest>(Anki::Vector::ExternalComms::RtsCloudSessionRequest member)
{
  return CreateRtsCloudSessionRequest(std::move(member));
}

void RtsConnection_3::Set_RtsCloudSessionRequest(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  if (this->_tag == Tag::RtsCloudSessionRequest) {
    this->_RtsCloudSessionRequest = std::move(new_RtsCloudSessionRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(new_RtsCloudSessionRequest));
    _tag = Tag::RtsCloudSessionRequest;
  }
}

RtsConnection_3 RtsConnection_3::CreateRtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  RtsConnection_3 m;
  m.Set_RtsCloudSessionResponse(new_RtsCloudSessionResponse);
  return m;
}

RtsConnection_3::RtsConnection_3(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
  _tag = Tag::RtsCloudSessionResponse;
}

const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_3::Get_RtsCloudSessionResponse() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

void RtsConnection_3::Set_RtsCloudSessionResponse(const Anki::Vector::ExternalComms::RtsCloudSessionResponse& new_RtsCloudSessionResponse)
{
  if(this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = new_RtsCloudSessionResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(new_RtsCloudSessionResponse);
    _tag = Tag::RtsCloudSessionResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_3::Get_<RtsConnection_3::Tag::RtsCloudSessionResponse>() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

template<>
RtsConnection_3 RtsConnection_3::Create_<RtsConnection_3::Tag::RtsCloudSessionResponse>(Anki::Vector::ExternalComms::RtsCloudSessionResponse member)
{
  return CreateRtsCloudSessionResponse(std::move(member));
}

void RtsConnection_3::Set_RtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  if (this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = std::move(new_RtsCloudSessionResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
    _tag = Tag::RtsCloudSessionResponse;
  }
}

size_t RtsConnection_3::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection_3::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(buffer);
    }
    else {
      this->_RtsConnRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsConnResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(buffer);
    }
    else {
      this->_RtsConnResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsNonceMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(buffer);
    }
    else {
      this->_RtsNonceMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(buffer);
    }
    else {
      this->_RtsChallengeMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeSuccessMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(buffer);
    }
    else {
      this->_RtsChallengeSuccessMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(buffer);
    }
    else {
      this->_RtsWifiConnectRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(buffer);
    }
    else {
      this->_RtsWifiConnectResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(buffer);
    }
    else {
      this->_RtsWifiIpRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(buffer);
    }
    else {
      this->_RtsWifiIpResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(buffer);
    }
    else {
      this->_RtsStatusRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusResponse_3)) Anki::Vector::ExternalComms::RtsStatusResponse_3(buffer);
    }
    else {
      this->_RtsStatusResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(buffer);
    }
    else {
      this->_RtsWifiScanRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(buffer);
    }
    else {
      this->_RtsWifiScanResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(buffer);
    }
    else {
      this->_RtsOtaUpdateRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(buffer);
    }
    else {
      this->_RtsOtaUpdateResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCancelPairing:
    if (newTag != oldTag) {
      new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(buffer);
    }
    else {
      this->_RtsCancelPairing.Unpack(buffer);
    }
    break;
  case Tag::RtsForceDisconnect:
    if (newTag != oldTag) {
      new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(buffer);
    }
    else {
      this->_RtsForceDisconnect.Unpack(buffer);
    }
    break;
  case Tag::RtsAck:
    if (newTag != oldTag) {
      new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(buffer);
    }
    else {
      this->_RtsAck.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(buffer);
    }
    else {
      this->_RtsWifiAccessPointRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(buffer);
    }
    else {
      this->_RtsWifiAccessPointResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSshRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(buffer);
    }
    else {
      this->_RtsSshRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSshResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(buffer);
    }
    else {
      this->_RtsSshResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaCancelRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(buffer);
    }
    else {
      this->_RtsOtaCancelRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(buffer);
    }
    else {
      this->_RtsLogRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(buffer);
    }
    else {
      this->_RtsLogResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsFileDownload:
    if (newTag != oldTag) {
      new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(buffer);
    }
    else {
      this->_RtsFileDownload.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(buffer);
    }
    else {
      this->_RtsWifiForgetRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(buffer);
    }
    else {
      this->_RtsWifiForgetResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(buffer);
    }
    else {
      this->_RtsCloudSessionRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(buffer);
    }
    else {
      this->_RtsCloudSessionResponse.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection_3::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection_3::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnRequest:
    this->_RtsConnRequest.Pack(buffer);
    break;
  case Tag::RtsConnResponse:
    this->_RtsConnResponse.Pack(buffer);
    break;
  case Tag::RtsNonceMessage:
    this->_RtsNonceMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeMessage:
    this->_RtsChallengeMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeSuccessMessage:
    this->_RtsChallengeSuccessMessage.Pack(buffer);
    break;
  case Tag::RtsWifiConnectRequest:
    this->_RtsWifiConnectRequest.Pack(buffer);
    break;
  case Tag::RtsWifiConnectResponse_3:
    this->_RtsWifiConnectResponse_3.Pack(buffer);
    break;
  case Tag::RtsWifiIpRequest:
    this->_RtsWifiIpRequest.Pack(buffer);
    break;
  case Tag::RtsWifiIpResponse:
    this->_RtsWifiIpResponse.Pack(buffer);
    break;
  case Tag::RtsStatusRequest:
    this->_RtsStatusRequest.Pack(buffer);
    break;
  case Tag::RtsStatusResponse_3:
    this->_RtsStatusResponse_3.Pack(buffer);
    break;
  case Tag::RtsWifiScanRequest:
    this->_RtsWifiScanRequest.Pack(buffer);
    break;
  case Tag::RtsWifiScanResponse_3:
    this->_RtsWifiScanResponse_3.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateRequest:
    this->_RtsOtaUpdateRequest.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateResponse:
    this->_RtsOtaUpdateResponse.Pack(buffer);
    break;
  case Tag::RtsCancelPairing:
    this->_RtsCancelPairing.Pack(buffer);
    break;
  case Tag::RtsForceDisconnect:
    this->_RtsForceDisconnect.Pack(buffer);
    break;
  case Tag::RtsAck:
    this->_RtsAck.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointRequest:
    this->_RtsWifiAccessPointRequest.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointResponse:
    this->_RtsWifiAccessPointResponse.Pack(buffer);
    break;
  case Tag::RtsSshRequest:
    this->_RtsSshRequest.Pack(buffer);
    break;
  case Tag::RtsSshResponse:
    this->_RtsSshResponse.Pack(buffer);
    break;
  case Tag::RtsOtaCancelRequest:
    this->_RtsOtaCancelRequest.Pack(buffer);
    break;
  case Tag::RtsLogRequest:
    this->_RtsLogRequest.Pack(buffer);
    break;
  case Tag::RtsLogResponse:
    this->_RtsLogResponse.Pack(buffer);
    break;
  case Tag::RtsFileDownload:
    this->_RtsFileDownload.Pack(buffer);
    break;
  case Tag::RtsWifiForgetRequest:
    this->_RtsWifiForgetRequest.Pack(buffer);
    break;
  case Tag::RtsWifiForgetResponse:
    this->_RtsWifiForgetResponse.Pack(buffer);
    break;
  case Tag::RtsCloudSessionRequest:
    this->_RtsCloudSessionRequest.Pack(buffer);
    break;
  case Tag::RtsCloudSessionResponse:
    this->_RtsCloudSessionResponse.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection_3::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnRequest:
    result += this->_RtsConnRequest.Size(); // RtsConnRequest
    break;
  case Tag::RtsConnResponse:
    result += this->_RtsConnResponse.Size(); // RtsConnResponse
    break;
  case Tag::RtsNonceMessage:
    result += this->_RtsNonceMessage.Size(); // RtsNonceMessage
    break;
  case Tag::RtsChallengeMessage:
    result += this->_RtsChallengeMessage.Size(); // RtsChallengeMessage
    break;
  case Tag::RtsChallengeSuccessMessage:
    result += this->_RtsChallengeSuccessMessage.Size(); // RtsChallengeSuccessMessage
    break;
  case Tag::RtsWifiConnectRequest:
    result += this->_RtsWifiConnectRequest.Size(); // RtsWifiConnectRequest
    break;
  case Tag::RtsWifiConnectResponse_3:
    result += this->_RtsWifiConnectResponse_3.Size(); // RtsWifiConnectResponse_3
    break;
  case Tag::RtsWifiIpRequest:
    result += this->_RtsWifiIpRequest.Size(); // RtsWifiIpRequest
    break;
  case Tag::RtsWifiIpResponse:
    result += this->_RtsWifiIpResponse.Size(); // RtsWifiIpResponse
    break;
  case Tag::RtsStatusRequest:
    result += this->_RtsStatusRequest.Size(); // RtsStatusRequest
    break;
  case Tag::RtsStatusResponse_3:
    result += this->_RtsStatusResponse_3.Size(); // RtsStatusResponse_3
    break;
  case Tag::RtsWifiScanRequest:
    result += this->_RtsWifiScanRequest.Size(); // RtsWifiScanRequest
    break;
  case Tag::RtsWifiScanResponse_3:
    result += this->_RtsWifiScanResponse_3.Size(); // RtsWifiScanResponse_3
    break;
  case Tag::RtsOtaUpdateRequest:
    result += this->_RtsOtaUpdateRequest.Size(); // RtsOtaUpdateRequest
    break;
  case Tag::RtsOtaUpdateResponse:
    result += this->_RtsOtaUpdateResponse.Size(); // RtsOtaUpdateResponse
    break;
  case Tag::RtsCancelPairing:
    result += this->_RtsCancelPairing.Size(); // RtsCancelPairing
    break;
  case Tag::RtsForceDisconnect:
    result += this->_RtsForceDisconnect.Size(); // RtsForceDisconnect
    break;
  case Tag::RtsAck:
    result += this->_RtsAck.Size(); // RtsAck
    break;
  case Tag::RtsWifiAccessPointRequest:
    result += this->_RtsWifiAccessPointRequest.Size(); // RtsWifiAccessPointRequest
    break;
  case Tag::RtsWifiAccessPointResponse:
    result += this->_RtsWifiAccessPointResponse.Size(); // RtsWifiAccessPointResponse
    break;
  case Tag::RtsSshRequest:
    result += this->_RtsSshRequest.Size(); // RtsSshRequest
    break;
  case Tag::RtsSshResponse:
    result += this->_RtsSshResponse.Size(); // RtsSshResponse
    break;
  case Tag::RtsOtaCancelRequest:
    result += this->_RtsOtaCancelRequest.Size(); // RtsOtaCancelRequest
    break;
  case Tag::RtsLogRequest:
    result += this->_RtsLogRequest.Size(); // RtsLogRequest
    break;
  case Tag::RtsLogResponse:
    result += this->_RtsLogResponse.Size(); // RtsLogResponse
    break;
  case Tag::RtsFileDownload:
    result += this->_RtsFileDownload.Size(); // RtsFileDownload
    break;
  case Tag::RtsWifiForgetRequest:
    result += this->_RtsWifiForgetRequest.Size(); // RtsWifiForgetRequest
    break;
  case Tag::RtsWifiForgetResponse:
    result += this->_RtsWifiForgetResponse.Size(); // RtsWifiForgetResponse
    break;
  case Tag::RtsCloudSessionRequest:
    result += this->_RtsCloudSessionRequest.Size(); // RtsCloudSessionRequest
    break;
  case Tag::RtsCloudSessionResponse:
    result += this->_RtsCloudSessionResponse.Size(); // RtsCloudSessionResponse
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection_3::operator==(const RtsConnection_3& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnRequest:
    return this->_RtsConnRequest == other._RtsConnRequest;
  case Tag::RtsConnResponse:
    return this->_RtsConnResponse == other._RtsConnResponse;
  case Tag::RtsNonceMessage:
    return this->_RtsNonceMessage == other._RtsNonceMessage;
  case Tag::RtsChallengeMessage:
    return this->_RtsChallengeMessage == other._RtsChallengeMessage;
  case Tag::RtsChallengeSuccessMessage:
    return this->_RtsChallengeSuccessMessage == other._RtsChallengeSuccessMessage;
  case Tag::RtsWifiConnectRequest:
    return this->_RtsWifiConnectRequest == other._RtsWifiConnectRequest;
  case Tag::RtsWifiConnectResponse_3:
    return this->_RtsWifiConnectResponse_3 == other._RtsWifiConnectResponse_3;
  case Tag::RtsWifiIpRequest:
    return this->_RtsWifiIpRequest == other._RtsWifiIpRequest;
  case Tag::RtsWifiIpResponse:
    return this->_RtsWifiIpResponse == other._RtsWifiIpResponse;
  case Tag::RtsStatusRequest:
    return this->_RtsStatusRequest == other._RtsStatusRequest;
  case Tag::RtsStatusResponse_3:
    return this->_RtsStatusResponse_3 == other._RtsStatusResponse_3;
  case Tag::RtsWifiScanRequest:
    return this->_RtsWifiScanRequest == other._RtsWifiScanRequest;
  case Tag::RtsWifiScanResponse_3:
    return this->_RtsWifiScanResponse_3 == other._RtsWifiScanResponse_3;
  case Tag::RtsOtaUpdateRequest:
    return this->_RtsOtaUpdateRequest == other._RtsOtaUpdateRequest;
  case Tag::RtsOtaUpdateResponse:
    return this->_RtsOtaUpdateResponse == other._RtsOtaUpdateResponse;
  case Tag::RtsCancelPairing:
    return this->_RtsCancelPairing == other._RtsCancelPairing;
  case Tag::RtsForceDisconnect:
    return this->_RtsForceDisconnect == other._RtsForceDisconnect;
  case Tag::RtsAck:
    return this->_RtsAck == other._RtsAck;
  case Tag::RtsWifiAccessPointRequest:
    return this->_RtsWifiAccessPointRequest == other._RtsWifiAccessPointRequest;
  case Tag::RtsWifiAccessPointResponse:
    return this->_RtsWifiAccessPointResponse == other._RtsWifiAccessPointResponse;
  case Tag::RtsSshRequest:
    return this->_RtsSshRequest == other._RtsSshRequest;
  case Tag::RtsSshResponse:
    return this->_RtsSshResponse == other._RtsSshResponse;
  case Tag::RtsOtaCancelRequest:
    return this->_RtsOtaCancelRequest == other._RtsOtaCancelRequest;
  case Tag::RtsLogRequest:
    return this->_RtsLogRequest == other._RtsLogRequest;
  case Tag::RtsLogResponse:
    return this->_RtsLogResponse == other._RtsLogResponse;
  case Tag::RtsFileDownload:
    return this->_RtsFileDownload == other._RtsFileDownload;
  case Tag::RtsWifiForgetRequest:
    return this->_RtsWifiForgetRequest == other._RtsWifiForgetRequest;
  case Tag::RtsWifiForgetResponse:
    return this->_RtsWifiForgetResponse == other._RtsWifiForgetResponse;
  case Tag::RtsCloudSessionRequest:
    return this->_RtsCloudSessionRequest == other._RtsCloudSessionRequest;
  case Tag::RtsCloudSessionResponse:
    return this->_RtsCloudSessionResponse == other._RtsCloudSessionResponse;
  default:
    return true;
  }
}

bool RtsConnection_3::operator!=(const RtsConnection_3& other) const
{
  return !(operator==(other));
}

void RtsConnection_3::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnRequest:
    _RtsConnRequest.~RtsConnRequest();
    break;
  case Tag::RtsConnResponse:
    _RtsConnResponse.~RtsConnResponse();
    break;
  case Tag::RtsNonceMessage:
    _RtsNonceMessage.~RtsNonceMessage();
    break;
  case Tag::RtsChallengeMessage:
    _RtsChallengeMessage.~RtsChallengeMessage();
    break;
  case Tag::RtsChallengeSuccessMessage:
    _RtsChallengeSuccessMessage.~RtsChallengeSuccessMessage();
    break;
  case Tag::RtsWifiConnectRequest:
    _RtsWifiConnectRequest.~RtsWifiConnectRequest();
    break;
  case Tag::RtsWifiConnectResponse_3:
    _RtsWifiConnectResponse_3.~RtsWifiConnectResponse_3();
    break;
  case Tag::RtsWifiIpRequest:
    _RtsWifiIpRequest.~RtsWifiIpRequest();
    break;
  case Tag::RtsWifiIpResponse:
    _RtsWifiIpResponse.~RtsWifiIpResponse();
    break;
  case Tag::RtsStatusRequest:
    _RtsStatusRequest.~RtsStatusRequest();
    break;
  case Tag::RtsStatusResponse_3:
    _RtsStatusResponse_3.~RtsStatusResponse_3();
    break;
  case Tag::RtsWifiScanRequest:
    _RtsWifiScanRequest.~RtsWifiScanRequest();
    break;
  case Tag::RtsWifiScanResponse_3:
    _RtsWifiScanResponse_3.~RtsWifiScanResponse_3();
    break;
  case Tag::RtsOtaUpdateRequest:
    _RtsOtaUpdateRequest.~RtsOtaUpdateRequest();
    break;
  case Tag::RtsOtaUpdateResponse:
    _RtsOtaUpdateResponse.~RtsOtaUpdateResponse();
    break;
  case Tag::RtsCancelPairing:
    _RtsCancelPairing.~RtsCancelPairing();
    break;
  case Tag::RtsForceDisconnect:
    _RtsForceDisconnect.~RtsForceDisconnect();
    break;
  case Tag::RtsAck:
    _RtsAck.~RtsAck();
    break;
  case Tag::RtsWifiAccessPointRequest:
    _RtsWifiAccessPointRequest.~RtsWifiAccessPointRequest();
    break;
  case Tag::RtsWifiAccessPointResponse:
    _RtsWifiAccessPointResponse.~RtsWifiAccessPointResponse();
    break;
  case Tag::RtsSshRequest:
    _RtsSshRequest.~RtsSshRequest();
    break;
  case Tag::RtsSshResponse:
    _RtsSshResponse.~RtsSshResponse();
    break;
  case Tag::RtsOtaCancelRequest:
    _RtsOtaCancelRequest.~RtsOtaCancelRequest();
    break;
  case Tag::RtsLogRequest:
    _RtsLogRequest.~RtsLogRequest();
    break;
  case Tag::RtsLogResponse:
    _RtsLogResponse.~RtsLogResponse();
    break;
  case Tag::RtsFileDownload:
    _RtsFileDownload.~RtsFileDownload();
    break;
  case Tag::RtsWifiForgetRequest:
    _RtsWifiForgetRequest.~RtsWifiForgetRequest();
    break;
  case Tag::RtsWifiForgetResponse:
    _RtsWifiForgetResponse.~RtsWifiForgetResponse();
    break;
  case Tag::RtsCloudSessionRequest:
    _RtsCloudSessionRequest.~RtsCloudSessionRequest();
    break;
  case Tag::RtsCloudSessionResponse:
    _RtsCloudSessionResponse.~RtsCloudSessionResponse();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnection_3TagToString(const RtsConnection_3Tag tag) {
  switch(tag) {
  case RtsConnection_3Tag::Error:
    return "Error";
  case RtsConnection_3Tag::RtsConnRequest:
    return "RtsConnRequest";
  case RtsConnection_3Tag::RtsConnResponse:
    return "RtsConnResponse";
  case RtsConnection_3Tag::RtsNonceMessage:
    return "RtsNonceMessage";
  case RtsConnection_3Tag::RtsChallengeMessage:
    return "RtsChallengeMessage";
  case RtsConnection_3Tag::RtsChallengeSuccessMessage:
    return "RtsChallengeSuccessMessage";
  case RtsConnection_3Tag::RtsWifiConnectRequest:
    return "RtsWifiConnectRequest";
  case RtsConnection_3Tag::RtsWifiConnectResponse_3:
    return "RtsWifiConnectResponse_3";
  case RtsConnection_3Tag::RtsWifiIpRequest:
    return "RtsWifiIpRequest";
  case RtsConnection_3Tag::RtsWifiIpResponse:
    return "RtsWifiIpResponse";
  case RtsConnection_3Tag::RtsStatusRequest:
    return "RtsStatusRequest";
  case RtsConnection_3Tag::RtsStatusResponse_3:
    return "RtsStatusResponse_3";
  case RtsConnection_3Tag::RtsWifiScanRequest:
    return "RtsWifiScanRequest";
  case RtsConnection_3Tag::RtsWifiScanResponse_3:
    return "RtsWifiScanResponse_3";
  case RtsConnection_3Tag::RtsOtaUpdateRequest:
    return "RtsOtaUpdateRequest";
  case RtsConnection_3Tag::RtsOtaUpdateResponse:
    return "RtsOtaUpdateResponse";
  case RtsConnection_3Tag::RtsCancelPairing:
    return "RtsCancelPairing";
  case RtsConnection_3Tag::RtsForceDisconnect:
    return "RtsForceDisconnect";
  case RtsConnection_3Tag::RtsAck:
    return "RtsAck";
  case RtsConnection_3Tag::RtsWifiAccessPointRequest:
    return "RtsWifiAccessPointRequest";
  case RtsConnection_3Tag::RtsWifiAccessPointResponse:
    return "RtsWifiAccessPointResponse";
  case RtsConnection_3Tag::RtsSshRequest:
    return "RtsSshRequest";
  case RtsConnection_3Tag::RtsSshResponse:
    return "RtsSshResponse";
  case RtsConnection_3Tag::RtsOtaCancelRequest:
    return "RtsOtaCancelRequest";
  case RtsConnection_3Tag::RtsLogRequest:
    return "RtsLogRequest";
  case RtsConnection_3Tag::RtsLogResponse:
    return "RtsLogResponse";
  case RtsConnection_3Tag::RtsFileDownload:
    return "RtsFileDownload";
  case RtsConnection_3Tag::RtsWifiForgetRequest:
    return "RtsWifiForgetRequest";
  case RtsConnection_3Tag::RtsWifiForgetResponse:
    return "RtsWifiForgetResponse";
  case RtsConnection_3Tag::RtsCloudSessionRequest:
    return "RtsCloudSessionRequest";
  case RtsConnection_3Tag::RtsCloudSessionResponse:
    return "RtsCloudSessionResponse";
  default:
    return "INVALID";
  }
}

const char* RtsConnection_3VersionHashStr = "f59203c2e552ce18ff3179aa162b9e41";

const uint8_t RtsConnection_3VersionHash[16] = { 
    0xf5, 0x92, 0x3, 0xc2, 0xe5, 0x52, 0xce, 0x18, 0xff, 0x31, 0x79, 0xaa, 0x16, 0x2b, 0x9e, 0x41 
};

// UNION RtsConnection_4

RtsConnection_4::RtsConnection_4(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection_4::RtsConnection_4(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection_4::RtsConnection_4(const RtsConnection_4& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_4:
    new(&(this->_RtsStatusResponse_4)) Anki::Vector::ExternalComms::RtsStatusResponse_4(other._RtsStatusResponse_4);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(other._RtsCloudSessionRequest);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(other._RtsAppConnectionIdRequest);
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(other._RtsAppConnectionIdResponse);
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(other._RtsResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection_4::RtsConnection_4(RtsConnection_4&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_4:
    new(&(this->_RtsStatusResponse_4)) Anki::Vector::ExternalComms::RtsStatusResponse_4(std::move(other._RtsStatusResponse_4));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(other._RtsCloudSessionRequest));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(other._RtsAppConnectionIdRequest));
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(other._RtsAppConnectionIdResponse));
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(std::move(other._RtsResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection_4& RtsConnection_4::operator=(const RtsConnection_4& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_4:
    new(&(this->_RtsStatusResponse_4)) Anki::Vector::ExternalComms::RtsStatusResponse_4(other._RtsStatusResponse_4);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(other._RtsCloudSessionRequest);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(other._RtsAppConnectionIdRequest);
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(other._RtsAppConnectionIdResponse);
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(other._RtsResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection_4& RtsConnection_4::operator=(RtsConnection_4&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_4:
    new(&(this->_RtsStatusResponse_4)) Anki::Vector::ExternalComms::RtsStatusResponse_4(std::move(other._RtsStatusResponse_4));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest:
    new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(other._RtsCloudSessionRequest));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(other._RtsAppConnectionIdRequest));
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(other._RtsAppConnectionIdResponse));
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(std::move(other._RtsResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection_4 RtsConnection_4::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection_4 m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection_4::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection_4::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection_4::Get_<RtsConnection_4::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection_4::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  RtsConnection_4 m;
  m.Set_RtsConnRequest(new_RtsConnRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
  _tag = Tag::RtsConnRequest;
}

const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_4::Get_RtsConnRequest() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

void RtsConnection_4::Set_RtsConnRequest(const Anki::Vector::ExternalComms::RtsConnRequest& new_RtsConnRequest)
{
  if(this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = new_RtsConnRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(new_RtsConnRequest);
    _tag = Tag::RtsConnRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsConnRequest>() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsConnRequest>(Anki::Vector::ExternalComms::RtsConnRequest member)
{
  return CreateRtsConnRequest(std::move(member));
}

void RtsConnection_4::Set_RtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  if (this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = std::move(new_RtsConnRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
    _tag = Tag::RtsConnRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  RtsConnection_4 m;
  m.Set_RtsConnResponse(new_RtsConnResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
  _tag = Tag::RtsConnResponse;
}

const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_4::Get_RtsConnResponse() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

void RtsConnection_4::Set_RtsConnResponse(const Anki::Vector::ExternalComms::RtsConnResponse& new_RtsConnResponse)
{
  if(this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = new_RtsConnResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(new_RtsConnResponse);
    _tag = Tag::RtsConnResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsConnResponse>() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsConnResponse>(Anki::Vector::ExternalComms::RtsConnResponse member)
{
  return CreateRtsConnResponse(std::move(member));
}

void RtsConnection_4::Set_RtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  if (this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = std::move(new_RtsConnResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
    _tag = Tag::RtsConnResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  RtsConnection_4 m;
  m.Set_RtsNonceMessage(new_RtsNonceMessage);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
  _tag = Tag::RtsNonceMessage;
}

const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_4::Get_RtsNonceMessage() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

void RtsConnection_4::Set_RtsNonceMessage(const Anki::Vector::ExternalComms::RtsNonceMessage& new_RtsNonceMessage)
{
  if(this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = new_RtsNonceMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(new_RtsNonceMessage);
    _tag = Tag::RtsNonceMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsNonceMessage>() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsNonceMessage>(Anki::Vector::ExternalComms::RtsNonceMessage member)
{
  return CreateRtsNonceMessage(std::move(member));
}

void RtsConnection_4::Set_RtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  if (this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = std::move(new_RtsNonceMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
    _tag = Tag::RtsNonceMessage;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  RtsConnection_4 m;
  m.Set_RtsChallengeMessage(new_RtsChallengeMessage);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
  _tag = Tag::RtsChallengeMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_4::Get_RtsChallengeMessage() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

void RtsConnection_4::Set_RtsChallengeMessage(const Anki::Vector::ExternalComms::RtsChallengeMessage& new_RtsChallengeMessage)
{
  if(this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = new_RtsChallengeMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(new_RtsChallengeMessage);
    _tag = Tag::RtsChallengeMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsChallengeMessage>() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsChallengeMessage>(Anki::Vector::ExternalComms::RtsChallengeMessage member)
{
  return CreateRtsChallengeMessage(std::move(member));
}

void RtsConnection_4::Set_RtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  if (this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = std::move(new_RtsChallengeMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
    _tag = Tag::RtsChallengeMessage;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  RtsConnection_4 m;
  m.Set_RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
  _tag = Tag::RtsChallengeSuccessMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_4::Get_RtsChallengeSuccessMessage() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

void RtsConnection_4::Set_RtsChallengeSuccessMessage(const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& new_RtsChallengeSuccessMessage)
{
  if(this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = new_RtsChallengeSuccessMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsChallengeSuccessMessage>() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsChallengeSuccessMessage>(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage member)
{
  return CreateRtsChallengeSuccessMessage(std::move(member));
}

void RtsConnection_4::Set_RtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  if (this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = std::move(new_RtsChallengeSuccessMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  RtsConnection_4 m;
  m.Set_RtsWifiConnectRequest(new_RtsWifiConnectRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
  _tag = Tag::RtsWifiConnectRequest;
}

const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_4::Get_RtsWifiConnectRequest() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

void RtsConnection_4::Set_RtsWifiConnectRequest(const Anki::Vector::ExternalComms::RtsWifiConnectRequest& new_RtsWifiConnectRequest)
{
  if(this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = new_RtsWifiConnectRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(new_RtsWifiConnectRequest);
    _tag = Tag::RtsWifiConnectRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiConnectRequest>() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiConnectRequest>(Anki::Vector::ExternalComms::RtsWifiConnectRequest member)
{
  return CreateRtsWifiConnectRequest(std::move(member));
}

void RtsConnection_4::Set_RtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  if (this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = std::move(new_RtsWifiConnectRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
    _tag = Tag::RtsWifiConnectRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  RtsConnection_4 m;
  m.Set_RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
  _tag = Tag::RtsWifiConnectResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_4::Get_RtsWifiConnectResponse_3() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

void RtsConnection_4::Set_RtsWifiConnectResponse_3(const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& new_RtsWifiConnectResponse_3)
{
  if(this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = new_RtsWifiConnectResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiConnectResponse_3>() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiConnectResponse_3>(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3 member)
{
  return CreateRtsWifiConnectResponse_3(std::move(member));
}

void RtsConnection_4::Set_RtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  if (this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = std::move(new_RtsWifiConnectResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  RtsConnection_4 m;
  m.Set_RtsWifiIpRequest(new_RtsWifiIpRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
  _tag = Tag::RtsWifiIpRequest;
}

const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_4::Get_RtsWifiIpRequest() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

void RtsConnection_4::Set_RtsWifiIpRequest(const Anki::Vector::ExternalComms::RtsWifiIpRequest& new_RtsWifiIpRequest)
{
  if(this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = new_RtsWifiIpRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(new_RtsWifiIpRequest);
    _tag = Tag::RtsWifiIpRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiIpRequest>() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiIpRequest>(Anki::Vector::ExternalComms::RtsWifiIpRequest member)
{
  return CreateRtsWifiIpRequest(std::move(member));
}

void RtsConnection_4::Set_RtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  if (this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = std::move(new_RtsWifiIpRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
    _tag = Tag::RtsWifiIpRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  RtsConnection_4 m;
  m.Set_RtsWifiIpResponse(new_RtsWifiIpResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
  _tag = Tag::RtsWifiIpResponse;
}

const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_4::Get_RtsWifiIpResponse() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

void RtsConnection_4::Set_RtsWifiIpResponse(const Anki::Vector::ExternalComms::RtsWifiIpResponse& new_RtsWifiIpResponse)
{
  if(this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = new_RtsWifiIpResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(new_RtsWifiIpResponse);
    _tag = Tag::RtsWifiIpResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiIpResponse>() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiIpResponse>(Anki::Vector::ExternalComms::RtsWifiIpResponse member)
{
  return CreateRtsWifiIpResponse(std::move(member));
}

void RtsConnection_4::Set_RtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  if (this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = std::move(new_RtsWifiIpResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
    _tag = Tag::RtsWifiIpResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  RtsConnection_4 m;
  m.Set_RtsStatusRequest(new_RtsStatusRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
  _tag = Tag::RtsStatusRequest;
}

const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_4::Get_RtsStatusRequest() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

void RtsConnection_4::Set_RtsStatusRequest(const Anki::Vector::ExternalComms::RtsStatusRequest& new_RtsStatusRequest)
{
  if(this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = new_RtsStatusRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(new_RtsStatusRequest);
    _tag = Tag::RtsStatusRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsStatusRequest>() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsStatusRequest>(Anki::Vector::ExternalComms::RtsStatusRequest member)
{
  return CreateRtsStatusRequest(std::move(member));
}

void RtsConnection_4::Set_RtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  if (this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = std::move(new_RtsStatusRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
    _tag = Tag::RtsStatusRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsStatusResponse_4(Anki::Vector::ExternalComms::RtsStatusResponse_4&& new_RtsStatusResponse_4)
{
  RtsConnection_4 m;
  m.Set_RtsStatusResponse_4(new_RtsStatusResponse_4);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsStatusResponse_4&& new_RtsStatusResponse_4)
{
  new(&this->_RtsStatusResponse_4) Anki::Vector::ExternalComms::RtsStatusResponse_4(std::move(new_RtsStatusResponse_4));
  _tag = Tag::RtsStatusResponse_4;
}

const Anki::Vector::ExternalComms::RtsStatusResponse_4& RtsConnection_4::Get_RtsStatusResponse_4() const
{
  assert(_tag == Tag::RtsStatusResponse_4);
  return this->_RtsStatusResponse_4;
}

void RtsConnection_4::Set_RtsStatusResponse_4(const Anki::Vector::ExternalComms::RtsStatusResponse_4& new_RtsStatusResponse_4)
{
  if(this->_tag == Tag::RtsStatusResponse_4) {
    this->_RtsStatusResponse_4 = new_RtsStatusResponse_4;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_4) Anki::Vector::ExternalComms::RtsStatusResponse_4(new_RtsStatusResponse_4);
    _tag = Tag::RtsStatusResponse_4;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusResponse_4& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsStatusResponse_4>() const
{
  assert(_tag == Tag::RtsStatusResponse_4);
  return this->_RtsStatusResponse_4;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsStatusResponse_4>(Anki::Vector::ExternalComms::RtsStatusResponse_4 member)
{
  return CreateRtsStatusResponse_4(std::move(member));
}

void RtsConnection_4::Set_RtsStatusResponse_4(Anki::Vector::ExternalComms::RtsStatusResponse_4&& new_RtsStatusResponse_4)
{
  if (this->_tag == Tag::RtsStatusResponse_4) {
    this->_RtsStatusResponse_4 = std::move(new_RtsStatusResponse_4);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_4) Anki::Vector::ExternalComms::RtsStatusResponse_4(std::move(new_RtsStatusResponse_4));
    _tag = Tag::RtsStatusResponse_4;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  RtsConnection_4 m;
  m.Set_RtsWifiScanRequest(new_RtsWifiScanRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
  _tag = Tag::RtsWifiScanRequest;
}

const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_4::Get_RtsWifiScanRequest() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

void RtsConnection_4::Set_RtsWifiScanRequest(const Anki::Vector::ExternalComms::RtsWifiScanRequest& new_RtsWifiScanRequest)
{
  if(this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = new_RtsWifiScanRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(new_RtsWifiScanRequest);
    _tag = Tag::RtsWifiScanRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiScanRequest>() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiScanRequest>(Anki::Vector::ExternalComms::RtsWifiScanRequest member)
{
  return CreateRtsWifiScanRequest(std::move(member));
}

void RtsConnection_4::Set_RtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  if (this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = std::move(new_RtsWifiScanRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
    _tag = Tag::RtsWifiScanRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  RtsConnection_4 m;
  m.Set_RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
  _tag = Tag::RtsWifiScanResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_4::Get_RtsWifiScanResponse_3() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

void RtsConnection_4::Set_RtsWifiScanResponse_3(const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& new_RtsWifiScanResponse_3)
{
  if(this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = new_RtsWifiScanResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiScanResponse_3>() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiScanResponse_3>(Anki::Vector::ExternalComms::RtsWifiScanResponse_3 member)
{
  return CreateRtsWifiScanResponse_3(std::move(member));
}

void RtsConnection_4::Set_RtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  if (this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = std::move(new_RtsWifiScanResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  RtsConnection_4 m;
  m.Set_RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
  _tag = Tag::RtsOtaUpdateRequest;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_4::Get_RtsOtaUpdateRequest() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

void RtsConnection_4::Set_RtsOtaUpdateRequest(const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& new_RtsOtaUpdateRequest)
{
  if(this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = new_RtsOtaUpdateRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsOtaUpdateRequest>() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsOtaUpdateRequest>(Anki::Vector::ExternalComms::RtsOtaUpdateRequest member)
{
  return CreateRtsOtaUpdateRequest(std::move(member));
}

void RtsConnection_4::Set_RtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  if (this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = std::move(new_RtsOtaUpdateRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  RtsConnection_4 m;
  m.Set_RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
  _tag = Tag::RtsOtaUpdateResponse;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_4::Get_RtsOtaUpdateResponse() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

void RtsConnection_4::Set_RtsOtaUpdateResponse(const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& new_RtsOtaUpdateResponse)
{
  if(this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = new_RtsOtaUpdateResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsOtaUpdateResponse>() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsOtaUpdateResponse>(Anki::Vector::ExternalComms::RtsOtaUpdateResponse member)
{
  return CreateRtsOtaUpdateResponse(std::move(member));
}

void RtsConnection_4::Set_RtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  if (this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = std::move(new_RtsOtaUpdateResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  RtsConnection_4 m;
  m.Set_RtsCancelPairing(new_RtsCancelPairing);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
  _tag = Tag::RtsCancelPairing;
}

const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_4::Get_RtsCancelPairing() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

void RtsConnection_4::Set_RtsCancelPairing(const Anki::Vector::ExternalComms::RtsCancelPairing& new_RtsCancelPairing)
{
  if(this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = new_RtsCancelPairing;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(new_RtsCancelPairing);
    _tag = Tag::RtsCancelPairing;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsCancelPairing>() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsCancelPairing>(Anki::Vector::ExternalComms::RtsCancelPairing member)
{
  return CreateRtsCancelPairing(std::move(member));
}

void RtsConnection_4::Set_RtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  if (this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = std::move(new_RtsCancelPairing);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
    _tag = Tag::RtsCancelPairing;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  RtsConnection_4 m;
  m.Set_RtsForceDisconnect(new_RtsForceDisconnect);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
  _tag = Tag::RtsForceDisconnect;
}

const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_4::Get_RtsForceDisconnect() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

void RtsConnection_4::Set_RtsForceDisconnect(const Anki::Vector::ExternalComms::RtsForceDisconnect& new_RtsForceDisconnect)
{
  if(this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = new_RtsForceDisconnect;
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(new_RtsForceDisconnect);
    _tag = Tag::RtsForceDisconnect;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsForceDisconnect>() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsForceDisconnect>(Anki::Vector::ExternalComms::RtsForceDisconnect member)
{
  return CreateRtsForceDisconnect(std::move(member));
}

void RtsConnection_4::Set_RtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  if (this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = std::move(new_RtsForceDisconnect);
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
    _tag = Tag::RtsForceDisconnect;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  RtsConnection_4 m;
  m.Set_RtsAck(new_RtsAck);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
  _tag = Tag::RtsAck;
}

const Anki::Vector::ExternalComms::RtsAck& RtsConnection_4::Get_RtsAck() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

void RtsConnection_4::Set_RtsAck(const Anki::Vector::ExternalComms::RtsAck& new_RtsAck)
{
  if(this->_tag == Tag::RtsAck) {
    this->_RtsAck = new_RtsAck;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(new_RtsAck);
    _tag = Tag::RtsAck;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAck& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsAck>() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsAck>(Anki::Vector::ExternalComms::RtsAck member)
{
  return CreateRtsAck(std::move(member));
}

void RtsConnection_4::Set_RtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  if (this->_tag == Tag::RtsAck) {
    this->_RtsAck = std::move(new_RtsAck);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
    _tag = Tag::RtsAck;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  RtsConnection_4 m;
  m.Set_RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
  _tag = Tag::RtsWifiAccessPointRequest;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_4::Get_RtsWifiAccessPointRequest() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

void RtsConnection_4::Set_RtsWifiAccessPointRequest(const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& new_RtsWifiAccessPointRequest)
{
  if(this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = new_RtsWifiAccessPointRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiAccessPointRequest>() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiAccessPointRequest>(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest member)
{
  return CreateRtsWifiAccessPointRequest(std::move(member));
}

void RtsConnection_4::Set_RtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  if (this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = std::move(new_RtsWifiAccessPointRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  RtsConnection_4 m;
  m.Set_RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
  _tag = Tag::RtsWifiAccessPointResponse;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_4::Get_RtsWifiAccessPointResponse() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

void RtsConnection_4::Set_RtsWifiAccessPointResponse(const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& new_RtsWifiAccessPointResponse)
{
  if(this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = new_RtsWifiAccessPointResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiAccessPointResponse>() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiAccessPointResponse>(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse member)
{
  return CreateRtsWifiAccessPointResponse(std::move(member));
}

void RtsConnection_4::Set_RtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  if (this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = std::move(new_RtsWifiAccessPointResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  RtsConnection_4 m;
  m.Set_RtsSshRequest(new_RtsSshRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
  _tag = Tag::RtsSshRequest;
}

const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_4::Get_RtsSshRequest() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

void RtsConnection_4::Set_RtsSshRequest(const Anki::Vector::ExternalComms::RtsSshRequest& new_RtsSshRequest)
{
  if(this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = new_RtsSshRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(new_RtsSshRequest);
    _tag = Tag::RtsSshRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsSshRequest>() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsSshRequest>(Anki::Vector::ExternalComms::RtsSshRequest member)
{
  return CreateRtsSshRequest(std::move(member));
}

void RtsConnection_4::Set_RtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  if (this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = std::move(new_RtsSshRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
    _tag = Tag::RtsSshRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  RtsConnection_4 m;
  m.Set_RtsSshResponse(new_RtsSshResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
  _tag = Tag::RtsSshResponse;
}

const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_4::Get_RtsSshResponse() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

void RtsConnection_4::Set_RtsSshResponse(const Anki::Vector::ExternalComms::RtsSshResponse& new_RtsSshResponse)
{
  if(this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = new_RtsSshResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(new_RtsSshResponse);
    _tag = Tag::RtsSshResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsSshResponse>() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsSshResponse>(Anki::Vector::ExternalComms::RtsSshResponse member)
{
  return CreateRtsSshResponse(std::move(member));
}

void RtsConnection_4::Set_RtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  if (this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = std::move(new_RtsSshResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
    _tag = Tag::RtsSshResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  RtsConnection_4 m;
  m.Set_RtsOtaCancelRequest(new_RtsOtaCancelRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
  _tag = Tag::RtsOtaCancelRequest;
}

const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_4::Get_RtsOtaCancelRequest() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

void RtsConnection_4::Set_RtsOtaCancelRequest(const Anki::Vector::ExternalComms::RtsOtaCancelRequest& new_RtsOtaCancelRequest)
{
  if(this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = new_RtsOtaCancelRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(new_RtsOtaCancelRequest);
    _tag = Tag::RtsOtaCancelRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsOtaCancelRequest>() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsOtaCancelRequest>(Anki::Vector::ExternalComms::RtsOtaCancelRequest member)
{
  return CreateRtsOtaCancelRequest(std::move(member));
}

void RtsConnection_4::Set_RtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  if (this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = std::move(new_RtsOtaCancelRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
    _tag = Tag::RtsOtaCancelRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  RtsConnection_4 m;
  m.Set_RtsLogRequest(new_RtsLogRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
  _tag = Tag::RtsLogRequest;
}

const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_4::Get_RtsLogRequest() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

void RtsConnection_4::Set_RtsLogRequest(const Anki::Vector::ExternalComms::RtsLogRequest& new_RtsLogRequest)
{
  if(this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = new_RtsLogRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(new_RtsLogRequest);
    _tag = Tag::RtsLogRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsLogRequest>() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsLogRequest>(Anki::Vector::ExternalComms::RtsLogRequest member)
{
  return CreateRtsLogRequest(std::move(member));
}

void RtsConnection_4::Set_RtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  if (this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = std::move(new_RtsLogRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
    _tag = Tag::RtsLogRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  RtsConnection_4 m;
  m.Set_RtsLogResponse(new_RtsLogResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
  _tag = Tag::RtsLogResponse;
}

const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_4::Get_RtsLogResponse() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

void RtsConnection_4::Set_RtsLogResponse(const Anki::Vector::ExternalComms::RtsLogResponse& new_RtsLogResponse)
{
  if(this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = new_RtsLogResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(new_RtsLogResponse);
    _tag = Tag::RtsLogResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsLogResponse>() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsLogResponse>(Anki::Vector::ExternalComms::RtsLogResponse member)
{
  return CreateRtsLogResponse(std::move(member));
}

void RtsConnection_4::Set_RtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  if (this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = std::move(new_RtsLogResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
    _tag = Tag::RtsLogResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  RtsConnection_4 m;
  m.Set_RtsFileDownload(new_RtsFileDownload);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
  _tag = Tag::RtsFileDownload;
}

const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_4::Get_RtsFileDownload() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

void RtsConnection_4::Set_RtsFileDownload(const Anki::Vector::ExternalComms::RtsFileDownload& new_RtsFileDownload)
{
  if(this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = new_RtsFileDownload;
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(new_RtsFileDownload);
    _tag = Tag::RtsFileDownload;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsFileDownload>() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsFileDownload>(Anki::Vector::ExternalComms::RtsFileDownload member)
{
  return CreateRtsFileDownload(std::move(member));
}

void RtsConnection_4::Set_RtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  if (this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = std::move(new_RtsFileDownload);
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
    _tag = Tag::RtsFileDownload;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  RtsConnection_4 m;
  m.Set_RtsWifiForgetRequest(new_RtsWifiForgetRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
  _tag = Tag::RtsWifiForgetRequest;
}

const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_4::Get_RtsWifiForgetRequest() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

void RtsConnection_4::Set_RtsWifiForgetRequest(const Anki::Vector::ExternalComms::RtsWifiForgetRequest& new_RtsWifiForgetRequest)
{
  if(this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = new_RtsWifiForgetRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(new_RtsWifiForgetRequest);
    _tag = Tag::RtsWifiForgetRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiForgetRequest>() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiForgetRequest>(Anki::Vector::ExternalComms::RtsWifiForgetRequest member)
{
  return CreateRtsWifiForgetRequest(std::move(member));
}

void RtsConnection_4::Set_RtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  if (this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = std::move(new_RtsWifiForgetRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
    _tag = Tag::RtsWifiForgetRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  RtsConnection_4 m;
  m.Set_RtsWifiForgetResponse(new_RtsWifiForgetResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
  _tag = Tag::RtsWifiForgetResponse;
}

const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_4::Get_RtsWifiForgetResponse() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

void RtsConnection_4::Set_RtsWifiForgetResponse(const Anki::Vector::ExternalComms::RtsWifiForgetResponse& new_RtsWifiForgetResponse)
{
  if(this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = new_RtsWifiForgetResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(new_RtsWifiForgetResponse);
    _tag = Tag::RtsWifiForgetResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsWifiForgetResponse>() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsWifiForgetResponse>(Anki::Vector::ExternalComms::RtsWifiForgetResponse member)
{
  return CreateRtsWifiForgetResponse(std::move(member));
}

void RtsConnection_4::Set_RtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  if (this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = std::move(new_RtsWifiForgetResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
    _tag = Tag::RtsWifiForgetResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsCloudSessionRequest(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  RtsConnection_4 m;
  m.Set_RtsCloudSessionRequest(new_RtsCloudSessionRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(new_RtsCloudSessionRequest));
  _tag = Tag::RtsCloudSessionRequest;
}

const Anki::Vector::ExternalComms::RtsCloudSessionRequest& RtsConnection_4::Get_RtsCloudSessionRequest() const
{
  assert(_tag == Tag::RtsCloudSessionRequest);
  return this->_RtsCloudSessionRequest;
}

void RtsConnection_4::Set_RtsCloudSessionRequest(const Anki::Vector::ExternalComms::RtsCloudSessionRequest& new_RtsCloudSessionRequest)
{
  if(this->_tag == Tag::RtsCloudSessionRequest) {
    this->_RtsCloudSessionRequest = new_RtsCloudSessionRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(new_RtsCloudSessionRequest);
    _tag = Tag::RtsCloudSessionRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsCloudSessionRequest>() const
{
  assert(_tag == Tag::RtsCloudSessionRequest);
  return this->_RtsCloudSessionRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsCloudSessionRequest>(Anki::Vector::ExternalComms::RtsCloudSessionRequest member)
{
  return CreateRtsCloudSessionRequest(std::move(member));
}

void RtsConnection_4::Set_RtsCloudSessionRequest(Anki::Vector::ExternalComms::RtsCloudSessionRequest&& new_RtsCloudSessionRequest)
{
  if (this->_tag == Tag::RtsCloudSessionRequest) {
    this->_RtsCloudSessionRequest = std::move(new_RtsCloudSessionRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest) Anki::Vector::ExternalComms::RtsCloudSessionRequest(std::move(new_RtsCloudSessionRequest));
    _tag = Tag::RtsCloudSessionRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  RtsConnection_4 m;
  m.Set_RtsCloudSessionResponse(new_RtsCloudSessionResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
  _tag = Tag::RtsCloudSessionResponse;
}

const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_4::Get_RtsCloudSessionResponse() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

void RtsConnection_4::Set_RtsCloudSessionResponse(const Anki::Vector::ExternalComms::RtsCloudSessionResponse& new_RtsCloudSessionResponse)
{
  if(this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = new_RtsCloudSessionResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(new_RtsCloudSessionResponse);
    _tag = Tag::RtsCloudSessionResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsCloudSessionResponse>() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsCloudSessionResponse>(Anki::Vector::ExternalComms::RtsCloudSessionResponse member)
{
  return CreateRtsCloudSessionResponse(std::move(member));
}

void RtsConnection_4::Set_RtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  if (this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = std::move(new_RtsCloudSessionResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
    _tag = Tag::RtsCloudSessionResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsAppConnectionIdRequest(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  RtsConnection_4 m;
  m.Set_RtsAppConnectionIdRequest(new_RtsAppConnectionIdRequest);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(new_RtsAppConnectionIdRequest));
  _tag = Tag::RtsAppConnectionIdRequest;
}

const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& RtsConnection_4::Get_RtsAppConnectionIdRequest() const
{
  assert(_tag == Tag::RtsAppConnectionIdRequest);
  return this->_RtsAppConnectionIdRequest;
}

void RtsConnection_4::Set_RtsAppConnectionIdRequest(const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& new_RtsAppConnectionIdRequest)
{
  if(this->_tag == Tag::RtsAppConnectionIdRequest) {
    this->_RtsAppConnectionIdRequest = new_RtsAppConnectionIdRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(new_RtsAppConnectionIdRequest);
    _tag = Tag::RtsAppConnectionIdRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsAppConnectionIdRequest>() const
{
  assert(_tag == Tag::RtsAppConnectionIdRequest);
  return this->_RtsAppConnectionIdRequest;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsAppConnectionIdRequest>(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest member)
{
  return CreateRtsAppConnectionIdRequest(std::move(member));
}

void RtsConnection_4::Set_RtsAppConnectionIdRequest(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  if (this->_tag == Tag::RtsAppConnectionIdRequest) {
    this->_RtsAppConnectionIdRequest = std::move(new_RtsAppConnectionIdRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(new_RtsAppConnectionIdRequest));
    _tag = Tag::RtsAppConnectionIdRequest;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsAppConnectionIdResponse(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  RtsConnection_4 m;
  m.Set_RtsAppConnectionIdResponse(new_RtsAppConnectionIdResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(new_RtsAppConnectionIdResponse));
  _tag = Tag::RtsAppConnectionIdResponse;
}

const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& RtsConnection_4::Get_RtsAppConnectionIdResponse() const
{
  assert(_tag == Tag::RtsAppConnectionIdResponse);
  return this->_RtsAppConnectionIdResponse;
}

void RtsConnection_4::Set_RtsAppConnectionIdResponse(const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& new_RtsAppConnectionIdResponse)
{
  if(this->_tag == Tag::RtsAppConnectionIdResponse) {
    this->_RtsAppConnectionIdResponse = new_RtsAppConnectionIdResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(new_RtsAppConnectionIdResponse);
    _tag = Tag::RtsAppConnectionIdResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsAppConnectionIdResponse>() const
{
  assert(_tag == Tag::RtsAppConnectionIdResponse);
  return this->_RtsAppConnectionIdResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsAppConnectionIdResponse>(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse member)
{
  return CreateRtsAppConnectionIdResponse(std::move(member));
}

void RtsConnection_4::Set_RtsAppConnectionIdResponse(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  if (this->_tag == Tag::RtsAppConnectionIdResponse) {
    this->_RtsAppConnectionIdResponse = std::move(new_RtsAppConnectionIdResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(new_RtsAppConnectionIdResponse));
    _tag = Tag::RtsAppConnectionIdResponse;
  }
}

RtsConnection_4 RtsConnection_4::CreateRtsResponse(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  RtsConnection_4 m;
  m.Set_RtsResponse(new_RtsResponse);
  return m;
}

RtsConnection_4::RtsConnection_4(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(std::move(new_RtsResponse));
  _tag = Tag::RtsResponse;
}

const Anki::Vector::ExternalComms::RtsResponse& RtsConnection_4::Get_RtsResponse() const
{
  assert(_tag == Tag::RtsResponse);
  return this->_RtsResponse;
}

void RtsConnection_4::Set_RtsResponse(const Anki::Vector::ExternalComms::RtsResponse& new_RtsResponse)
{
  if(this->_tag == Tag::RtsResponse) {
    this->_RtsResponse = new_RtsResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(new_RtsResponse);
    _tag = Tag::RtsResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsResponse& RtsConnection_4::Get_<RtsConnection_4::Tag::RtsResponse>() const
{
  assert(_tag == Tag::RtsResponse);
  return this->_RtsResponse;
}

template<>
RtsConnection_4 RtsConnection_4::Create_<RtsConnection_4::Tag::RtsResponse>(Anki::Vector::ExternalComms::RtsResponse member)
{
  return CreateRtsResponse(std::move(member));
}

void RtsConnection_4::Set_RtsResponse(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  if (this->_tag == Tag::RtsResponse) {
    this->_RtsResponse = std::move(new_RtsResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(std::move(new_RtsResponse));
    _tag = Tag::RtsResponse;
  }
}

size_t RtsConnection_4::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection_4::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(buffer);
    }
    else {
      this->_RtsConnRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsConnResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(buffer);
    }
    else {
      this->_RtsConnResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsNonceMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(buffer);
    }
    else {
      this->_RtsNonceMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(buffer);
    }
    else {
      this->_RtsChallengeMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeSuccessMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(buffer);
    }
    else {
      this->_RtsChallengeSuccessMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(buffer);
    }
    else {
      this->_RtsWifiConnectRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(buffer);
    }
    else {
      this->_RtsWifiConnectResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(buffer);
    }
    else {
      this->_RtsWifiIpRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(buffer);
    }
    else {
      this->_RtsWifiIpResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(buffer);
    }
    else {
      this->_RtsStatusRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusResponse_4:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusResponse_4)) Anki::Vector::ExternalComms::RtsStatusResponse_4(buffer);
    }
    else {
      this->_RtsStatusResponse_4.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(buffer);
    }
    else {
      this->_RtsWifiScanRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(buffer);
    }
    else {
      this->_RtsWifiScanResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(buffer);
    }
    else {
      this->_RtsOtaUpdateRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(buffer);
    }
    else {
      this->_RtsOtaUpdateResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCancelPairing:
    if (newTag != oldTag) {
      new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(buffer);
    }
    else {
      this->_RtsCancelPairing.Unpack(buffer);
    }
    break;
  case Tag::RtsForceDisconnect:
    if (newTag != oldTag) {
      new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(buffer);
    }
    else {
      this->_RtsForceDisconnect.Unpack(buffer);
    }
    break;
  case Tag::RtsAck:
    if (newTag != oldTag) {
      new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(buffer);
    }
    else {
      this->_RtsAck.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(buffer);
    }
    else {
      this->_RtsWifiAccessPointRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(buffer);
    }
    else {
      this->_RtsWifiAccessPointResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSshRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(buffer);
    }
    else {
      this->_RtsSshRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSshResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(buffer);
    }
    else {
      this->_RtsSshResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaCancelRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(buffer);
    }
    else {
      this->_RtsOtaCancelRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(buffer);
    }
    else {
      this->_RtsLogRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(buffer);
    }
    else {
      this->_RtsLogResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsFileDownload:
    if (newTag != oldTag) {
      new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(buffer);
    }
    else {
      this->_RtsFileDownload.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(buffer);
    }
    else {
      this->_RtsWifiForgetRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(buffer);
    }
    else {
      this->_RtsWifiForgetResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionRequest)) Anki::Vector::ExternalComms::RtsCloudSessionRequest(buffer);
    }
    else {
      this->_RtsCloudSessionRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(buffer);
    }
    else {
      this->_RtsCloudSessionResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsAppConnectionIdRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(buffer);
    }
    else {
      this->_RtsAppConnectionIdRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsAppConnectionIdResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(buffer);
    }
    else {
      this->_RtsAppConnectionIdResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(buffer);
    }
    else {
      this->_RtsResponse.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection_4::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection_4::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnRequest:
    this->_RtsConnRequest.Pack(buffer);
    break;
  case Tag::RtsConnResponse:
    this->_RtsConnResponse.Pack(buffer);
    break;
  case Tag::RtsNonceMessage:
    this->_RtsNonceMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeMessage:
    this->_RtsChallengeMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeSuccessMessage:
    this->_RtsChallengeSuccessMessage.Pack(buffer);
    break;
  case Tag::RtsWifiConnectRequest:
    this->_RtsWifiConnectRequest.Pack(buffer);
    break;
  case Tag::RtsWifiConnectResponse_3:
    this->_RtsWifiConnectResponse_3.Pack(buffer);
    break;
  case Tag::RtsWifiIpRequest:
    this->_RtsWifiIpRequest.Pack(buffer);
    break;
  case Tag::RtsWifiIpResponse:
    this->_RtsWifiIpResponse.Pack(buffer);
    break;
  case Tag::RtsStatusRequest:
    this->_RtsStatusRequest.Pack(buffer);
    break;
  case Tag::RtsStatusResponse_4:
    this->_RtsStatusResponse_4.Pack(buffer);
    break;
  case Tag::RtsWifiScanRequest:
    this->_RtsWifiScanRequest.Pack(buffer);
    break;
  case Tag::RtsWifiScanResponse_3:
    this->_RtsWifiScanResponse_3.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateRequest:
    this->_RtsOtaUpdateRequest.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateResponse:
    this->_RtsOtaUpdateResponse.Pack(buffer);
    break;
  case Tag::RtsCancelPairing:
    this->_RtsCancelPairing.Pack(buffer);
    break;
  case Tag::RtsForceDisconnect:
    this->_RtsForceDisconnect.Pack(buffer);
    break;
  case Tag::RtsAck:
    this->_RtsAck.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointRequest:
    this->_RtsWifiAccessPointRequest.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointResponse:
    this->_RtsWifiAccessPointResponse.Pack(buffer);
    break;
  case Tag::RtsSshRequest:
    this->_RtsSshRequest.Pack(buffer);
    break;
  case Tag::RtsSshResponse:
    this->_RtsSshResponse.Pack(buffer);
    break;
  case Tag::RtsOtaCancelRequest:
    this->_RtsOtaCancelRequest.Pack(buffer);
    break;
  case Tag::RtsLogRequest:
    this->_RtsLogRequest.Pack(buffer);
    break;
  case Tag::RtsLogResponse:
    this->_RtsLogResponse.Pack(buffer);
    break;
  case Tag::RtsFileDownload:
    this->_RtsFileDownload.Pack(buffer);
    break;
  case Tag::RtsWifiForgetRequest:
    this->_RtsWifiForgetRequest.Pack(buffer);
    break;
  case Tag::RtsWifiForgetResponse:
    this->_RtsWifiForgetResponse.Pack(buffer);
    break;
  case Tag::RtsCloudSessionRequest:
    this->_RtsCloudSessionRequest.Pack(buffer);
    break;
  case Tag::RtsCloudSessionResponse:
    this->_RtsCloudSessionResponse.Pack(buffer);
    break;
  case Tag::RtsAppConnectionIdRequest:
    this->_RtsAppConnectionIdRequest.Pack(buffer);
    break;
  case Tag::RtsAppConnectionIdResponse:
    this->_RtsAppConnectionIdResponse.Pack(buffer);
    break;
  case Tag::RtsResponse:
    this->_RtsResponse.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection_4::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnRequest:
    result += this->_RtsConnRequest.Size(); // RtsConnRequest
    break;
  case Tag::RtsConnResponse:
    result += this->_RtsConnResponse.Size(); // RtsConnResponse
    break;
  case Tag::RtsNonceMessage:
    result += this->_RtsNonceMessage.Size(); // RtsNonceMessage
    break;
  case Tag::RtsChallengeMessage:
    result += this->_RtsChallengeMessage.Size(); // RtsChallengeMessage
    break;
  case Tag::RtsChallengeSuccessMessage:
    result += this->_RtsChallengeSuccessMessage.Size(); // RtsChallengeSuccessMessage
    break;
  case Tag::RtsWifiConnectRequest:
    result += this->_RtsWifiConnectRequest.Size(); // RtsWifiConnectRequest
    break;
  case Tag::RtsWifiConnectResponse_3:
    result += this->_RtsWifiConnectResponse_3.Size(); // RtsWifiConnectResponse_3
    break;
  case Tag::RtsWifiIpRequest:
    result += this->_RtsWifiIpRequest.Size(); // RtsWifiIpRequest
    break;
  case Tag::RtsWifiIpResponse:
    result += this->_RtsWifiIpResponse.Size(); // RtsWifiIpResponse
    break;
  case Tag::RtsStatusRequest:
    result += this->_RtsStatusRequest.Size(); // RtsStatusRequest
    break;
  case Tag::RtsStatusResponse_4:
    result += this->_RtsStatusResponse_4.Size(); // RtsStatusResponse_4
    break;
  case Tag::RtsWifiScanRequest:
    result += this->_RtsWifiScanRequest.Size(); // RtsWifiScanRequest
    break;
  case Tag::RtsWifiScanResponse_3:
    result += this->_RtsWifiScanResponse_3.Size(); // RtsWifiScanResponse_3
    break;
  case Tag::RtsOtaUpdateRequest:
    result += this->_RtsOtaUpdateRequest.Size(); // RtsOtaUpdateRequest
    break;
  case Tag::RtsOtaUpdateResponse:
    result += this->_RtsOtaUpdateResponse.Size(); // RtsOtaUpdateResponse
    break;
  case Tag::RtsCancelPairing:
    result += this->_RtsCancelPairing.Size(); // RtsCancelPairing
    break;
  case Tag::RtsForceDisconnect:
    result += this->_RtsForceDisconnect.Size(); // RtsForceDisconnect
    break;
  case Tag::RtsAck:
    result += this->_RtsAck.Size(); // RtsAck
    break;
  case Tag::RtsWifiAccessPointRequest:
    result += this->_RtsWifiAccessPointRequest.Size(); // RtsWifiAccessPointRequest
    break;
  case Tag::RtsWifiAccessPointResponse:
    result += this->_RtsWifiAccessPointResponse.Size(); // RtsWifiAccessPointResponse
    break;
  case Tag::RtsSshRequest:
    result += this->_RtsSshRequest.Size(); // RtsSshRequest
    break;
  case Tag::RtsSshResponse:
    result += this->_RtsSshResponse.Size(); // RtsSshResponse
    break;
  case Tag::RtsOtaCancelRequest:
    result += this->_RtsOtaCancelRequest.Size(); // RtsOtaCancelRequest
    break;
  case Tag::RtsLogRequest:
    result += this->_RtsLogRequest.Size(); // RtsLogRequest
    break;
  case Tag::RtsLogResponse:
    result += this->_RtsLogResponse.Size(); // RtsLogResponse
    break;
  case Tag::RtsFileDownload:
    result += this->_RtsFileDownload.Size(); // RtsFileDownload
    break;
  case Tag::RtsWifiForgetRequest:
    result += this->_RtsWifiForgetRequest.Size(); // RtsWifiForgetRequest
    break;
  case Tag::RtsWifiForgetResponse:
    result += this->_RtsWifiForgetResponse.Size(); // RtsWifiForgetResponse
    break;
  case Tag::RtsCloudSessionRequest:
    result += this->_RtsCloudSessionRequest.Size(); // RtsCloudSessionRequest
    break;
  case Tag::RtsCloudSessionResponse:
    result += this->_RtsCloudSessionResponse.Size(); // RtsCloudSessionResponse
    break;
  case Tag::RtsAppConnectionIdRequest:
    result += this->_RtsAppConnectionIdRequest.Size(); // RtsAppConnectionIdRequest
    break;
  case Tag::RtsAppConnectionIdResponse:
    result += this->_RtsAppConnectionIdResponse.Size(); // RtsAppConnectionIdResponse
    break;
  case Tag::RtsResponse:
    result += this->_RtsResponse.Size(); // RtsResponse
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection_4::operator==(const RtsConnection_4& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnRequest:
    return this->_RtsConnRequest == other._RtsConnRequest;
  case Tag::RtsConnResponse:
    return this->_RtsConnResponse == other._RtsConnResponse;
  case Tag::RtsNonceMessage:
    return this->_RtsNonceMessage == other._RtsNonceMessage;
  case Tag::RtsChallengeMessage:
    return this->_RtsChallengeMessage == other._RtsChallengeMessage;
  case Tag::RtsChallengeSuccessMessage:
    return this->_RtsChallengeSuccessMessage == other._RtsChallengeSuccessMessage;
  case Tag::RtsWifiConnectRequest:
    return this->_RtsWifiConnectRequest == other._RtsWifiConnectRequest;
  case Tag::RtsWifiConnectResponse_3:
    return this->_RtsWifiConnectResponse_3 == other._RtsWifiConnectResponse_3;
  case Tag::RtsWifiIpRequest:
    return this->_RtsWifiIpRequest == other._RtsWifiIpRequest;
  case Tag::RtsWifiIpResponse:
    return this->_RtsWifiIpResponse == other._RtsWifiIpResponse;
  case Tag::RtsStatusRequest:
    return this->_RtsStatusRequest == other._RtsStatusRequest;
  case Tag::RtsStatusResponse_4:
    return this->_RtsStatusResponse_4 == other._RtsStatusResponse_4;
  case Tag::RtsWifiScanRequest:
    return this->_RtsWifiScanRequest == other._RtsWifiScanRequest;
  case Tag::RtsWifiScanResponse_3:
    return this->_RtsWifiScanResponse_3 == other._RtsWifiScanResponse_3;
  case Tag::RtsOtaUpdateRequest:
    return this->_RtsOtaUpdateRequest == other._RtsOtaUpdateRequest;
  case Tag::RtsOtaUpdateResponse:
    return this->_RtsOtaUpdateResponse == other._RtsOtaUpdateResponse;
  case Tag::RtsCancelPairing:
    return this->_RtsCancelPairing == other._RtsCancelPairing;
  case Tag::RtsForceDisconnect:
    return this->_RtsForceDisconnect == other._RtsForceDisconnect;
  case Tag::RtsAck:
    return this->_RtsAck == other._RtsAck;
  case Tag::RtsWifiAccessPointRequest:
    return this->_RtsWifiAccessPointRequest == other._RtsWifiAccessPointRequest;
  case Tag::RtsWifiAccessPointResponse:
    return this->_RtsWifiAccessPointResponse == other._RtsWifiAccessPointResponse;
  case Tag::RtsSshRequest:
    return this->_RtsSshRequest == other._RtsSshRequest;
  case Tag::RtsSshResponse:
    return this->_RtsSshResponse == other._RtsSshResponse;
  case Tag::RtsOtaCancelRequest:
    return this->_RtsOtaCancelRequest == other._RtsOtaCancelRequest;
  case Tag::RtsLogRequest:
    return this->_RtsLogRequest == other._RtsLogRequest;
  case Tag::RtsLogResponse:
    return this->_RtsLogResponse == other._RtsLogResponse;
  case Tag::RtsFileDownload:
    return this->_RtsFileDownload == other._RtsFileDownload;
  case Tag::RtsWifiForgetRequest:
    return this->_RtsWifiForgetRequest == other._RtsWifiForgetRequest;
  case Tag::RtsWifiForgetResponse:
    return this->_RtsWifiForgetResponse == other._RtsWifiForgetResponse;
  case Tag::RtsCloudSessionRequest:
    return this->_RtsCloudSessionRequest == other._RtsCloudSessionRequest;
  case Tag::RtsCloudSessionResponse:
    return this->_RtsCloudSessionResponse == other._RtsCloudSessionResponse;
  case Tag::RtsAppConnectionIdRequest:
    return this->_RtsAppConnectionIdRequest == other._RtsAppConnectionIdRequest;
  case Tag::RtsAppConnectionIdResponse:
    return this->_RtsAppConnectionIdResponse == other._RtsAppConnectionIdResponse;
  case Tag::RtsResponse:
    return this->_RtsResponse == other._RtsResponse;
  default:
    return true;
  }
}

bool RtsConnection_4::operator!=(const RtsConnection_4& other) const
{
  return !(operator==(other));
}

void RtsConnection_4::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnRequest:
    _RtsConnRequest.~RtsConnRequest();
    break;
  case Tag::RtsConnResponse:
    _RtsConnResponse.~RtsConnResponse();
    break;
  case Tag::RtsNonceMessage:
    _RtsNonceMessage.~RtsNonceMessage();
    break;
  case Tag::RtsChallengeMessage:
    _RtsChallengeMessage.~RtsChallengeMessage();
    break;
  case Tag::RtsChallengeSuccessMessage:
    _RtsChallengeSuccessMessage.~RtsChallengeSuccessMessage();
    break;
  case Tag::RtsWifiConnectRequest:
    _RtsWifiConnectRequest.~RtsWifiConnectRequest();
    break;
  case Tag::RtsWifiConnectResponse_3:
    _RtsWifiConnectResponse_3.~RtsWifiConnectResponse_3();
    break;
  case Tag::RtsWifiIpRequest:
    _RtsWifiIpRequest.~RtsWifiIpRequest();
    break;
  case Tag::RtsWifiIpResponse:
    _RtsWifiIpResponse.~RtsWifiIpResponse();
    break;
  case Tag::RtsStatusRequest:
    _RtsStatusRequest.~RtsStatusRequest();
    break;
  case Tag::RtsStatusResponse_4:
    _RtsStatusResponse_4.~RtsStatusResponse_4();
    break;
  case Tag::RtsWifiScanRequest:
    _RtsWifiScanRequest.~RtsWifiScanRequest();
    break;
  case Tag::RtsWifiScanResponse_3:
    _RtsWifiScanResponse_3.~RtsWifiScanResponse_3();
    break;
  case Tag::RtsOtaUpdateRequest:
    _RtsOtaUpdateRequest.~RtsOtaUpdateRequest();
    break;
  case Tag::RtsOtaUpdateResponse:
    _RtsOtaUpdateResponse.~RtsOtaUpdateResponse();
    break;
  case Tag::RtsCancelPairing:
    _RtsCancelPairing.~RtsCancelPairing();
    break;
  case Tag::RtsForceDisconnect:
    _RtsForceDisconnect.~RtsForceDisconnect();
    break;
  case Tag::RtsAck:
    _RtsAck.~RtsAck();
    break;
  case Tag::RtsWifiAccessPointRequest:
    _RtsWifiAccessPointRequest.~RtsWifiAccessPointRequest();
    break;
  case Tag::RtsWifiAccessPointResponse:
    _RtsWifiAccessPointResponse.~RtsWifiAccessPointResponse();
    break;
  case Tag::RtsSshRequest:
    _RtsSshRequest.~RtsSshRequest();
    break;
  case Tag::RtsSshResponse:
    _RtsSshResponse.~RtsSshResponse();
    break;
  case Tag::RtsOtaCancelRequest:
    _RtsOtaCancelRequest.~RtsOtaCancelRequest();
    break;
  case Tag::RtsLogRequest:
    _RtsLogRequest.~RtsLogRequest();
    break;
  case Tag::RtsLogResponse:
    _RtsLogResponse.~RtsLogResponse();
    break;
  case Tag::RtsFileDownload:
    _RtsFileDownload.~RtsFileDownload();
    break;
  case Tag::RtsWifiForgetRequest:
    _RtsWifiForgetRequest.~RtsWifiForgetRequest();
    break;
  case Tag::RtsWifiForgetResponse:
    _RtsWifiForgetResponse.~RtsWifiForgetResponse();
    break;
  case Tag::RtsCloudSessionRequest:
    _RtsCloudSessionRequest.~RtsCloudSessionRequest();
    break;
  case Tag::RtsCloudSessionResponse:
    _RtsCloudSessionResponse.~RtsCloudSessionResponse();
    break;
  case Tag::RtsAppConnectionIdRequest:
    _RtsAppConnectionIdRequest.~RtsAppConnectionIdRequest();
    break;
  case Tag::RtsAppConnectionIdResponse:
    _RtsAppConnectionIdResponse.~RtsAppConnectionIdResponse();
    break;
  case Tag::RtsResponse:
    _RtsResponse.~RtsResponse();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnection_4TagToString(const RtsConnection_4Tag tag) {
  switch(tag) {
  case RtsConnection_4Tag::Error:
    return "Error";
  case RtsConnection_4Tag::RtsConnRequest:
    return "RtsConnRequest";
  case RtsConnection_4Tag::RtsConnResponse:
    return "RtsConnResponse";
  case RtsConnection_4Tag::RtsNonceMessage:
    return "RtsNonceMessage";
  case RtsConnection_4Tag::RtsChallengeMessage:
    return "RtsChallengeMessage";
  case RtsConnection_4Tag::RtsChallengeSuccessMessage:
    return "RtsChallengeSuccessMessage";
  case RtsConnection_4Tag::RtsWifiConnectRequest:
    return "RtsWifiConnectRequest";
  case RtsConnection_4Tag::RtsWifiConnectResponse_3:
    return "RtsWifiConnectResponse_3";
  case RtsConnection_4Tag::RtsWifiIpRequest:
    return "RtsWifiIpRequest";
  case RtsConnection_4Tag::RtsWifiIpResponse:
    return "RtsWifiIpResponse";
  case RtsConnection_4Tag::RtsStatusRequest:
    return "RtsStatusRequest";
  case RtsConnection_4Tag::RtsStatusResponse_4:
    return "RtsStatusResponse_4";
  case RtsConnection_4Tag::RtsWifiScanRequest:
    return "RtsWifiScanRequest";
  case RtsConnection_4Tag::RtsWifiScanResponse_3:
    return "RtsWifiScanResponse_3";
  case RtsConnection_4Tag::RtsOtaUpdateRequest:
    return "RtsOtaUpdateRequest";
  case RtsConnection_4Tag::RtsOtaUpdateResponse:
    return "RtsOtaUpdateResponse";
  case RtsConnection_4Tag::RtsCancelPairing:
    return "RtsCancelPairing";
  case RtsConnection_4Tag::RtsForceDisconnect:
    return "RtsForceDisconnect";
  case RtsConnection_4Tag::RtsAck:
    return "RtsAck";
  case RtsConnection_4Tag::RtsWifiAccessPointRequest:
    return "RtsWifiAccessPointRequest";
  case RtsConnection_4Tag::RtsWifiAccessPointResponse:
    return "RtsWifiAccessPointResponse";
  case RtsConnection_4Tag::RtsSshRequest:
    return "RtsSshRequest";
  case RtsConnection_4Tag::RtsSshResponse:
    return "RtsSshResponse";
  case RtsConnection_4Tag::RtsOtaCancelRequest:
    return "RtsOtaCancelRequest";
  case RtsConnection_4Tag::RtsLogRequest:
    return "RtsLogRequest";
  case RtsConnection_4Tag::RtsLogResponse:
    return "RtsLogResponse";
  case RtsConnection_4Tag::RtsFileDownload:
    return "RtsFileDownload";
  case RtsConnection_4Tag::RtsWifiForgetRequest:
    return "RtsWifiForgetRequest";
  case RtsConnection_4Tag::RtsWifiForgetResponse:
    return "RtsWifiForgetResponse";
  case RtsConnection_4Tag::RtsCloudSessionRequest:
    return "RtsCloudSessionRequest";
  case RtsConnection_4Tag::RtsCloudSessionResponse:
    return "RtsCloudSessionResponse";
  case RtsConnection_4Tag::RtsAppConnectionIdRequest:
    return "RtsAppConnectionIdRequest";
  case RtsConnection_4Tag::RtsAppConnectionIdResponse:
    return "RtsAppConnectionIdResponse";
  case RtsConnection_4Tag::RtsResponse:
    return "RtsResponse";
  default:
    return "INVALID";
  }
}

const char* RtsConnection_4VersionHashStr = "63d392bed59b5e66be87740b304580f1";

const uint8_t RtsConnection_4VersionHash[16] = { 
    0x63, 0xd3, 0x92, 0xbe, 0xd5, 0x9b, 0x5e, 0x66, 0xbe, 0x87, 0x74, 0xb, 0x30, 0x45, 0x80, 0xf1 
};

// UNION RtsConnection_5

RtsConnection_5::RtsConnection_5(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection_5::RtsConnection_5(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection_5::RtsConnection_5(const RtsConnection_5& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_5:
    new(&(this->_RtsStatusResponse_5)) Anki::Vector::ExternalComms::RtsStatusResponse_5(other._RtsStatusResponse_5);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest_2:
    new(&(this->_RtsCloudSessionRequest_2)) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(other._RtsCloudSessionRequest_2);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(other._RtsAppConnectionIdRequest);
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(other._RtsAppConnectionIdResponse);
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(other._RtsResponse);
    break;
  case Tag::RtsSdkProxyRequest:
    new(&(this->_RtsSdkProxyRequest)) Anki::Vector::ExternalComms::RtsSdkProxyRequest(other._RtsSdkProxyRequest);
    break;
  case Tag::RtsSdkProxyResponse:
    new(&(this->_RtsSdkProxyResponse)) Anki::Vector::ExternalComms::RtsSdkProxyResponse(other._RtsSdkProxyResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection_5::RtsConnection_5(RtsConnection_5&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_5:
    new(&(this->_RtsStatusResponse_5)) Anki::Vector::ExternalComms::RtsStatusResponse_5(std::move(other._RtsStatusResponse_5));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest_2:
    new(&(this->_RtsCloudSessionRequest_2)) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(std::move(other._RtsCloudSessionRequest_2));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(other._RtsAppConnectionIdRequest));
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(other._RtsAppConnectionIdResponse));
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(std::move(other._RtsResponse));
    break;
  case Tag::RtsSdkProxyRequest:
    new(&(this->_RtsSdkProxyRequest)) Anki::Vector::ExternalComms::RtsSdkProxyRequest(std::move(other._RtsSdkProxyRequest));
    break;
  case Tag::RtsSdkProxyResponse:
    new(&(this->_RtsSdkProxyResponse)) Anki::Vector::ExternalComms::RtsSdkProxyResponse(std::move(other._RtsSdkProxyResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection_5& RtsConnection_5::operator=(const RtsConnection_5& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(other._RtsWifiConnectResponse_3);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse_5:
    new(&(this->_RtsStatusResponse_5)) Anki::Vector::ExternalComms::RtsStatusResponse_5(other._RtsStatusResponse_5);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(other._RtsWifiScanResponse_3);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(other._RtsOtaCancelRequest);
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(other._RtsLogRequest);
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(other._RtsLogResponse);
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(other._RtsFileDownload);
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(other._RtsWifiForgetRequest);
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(other._RtsWifiForgetResponse);
    break;
  case Tag::RtsCloudSessionRequest_2:
    new(&(this->_RtsCloudSessionRequest_2)) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(other._RtsCloudSessionRequest_2);
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(other._RtsCloudSessionResponse);
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(other._RtsAppConnectionIdRequest);
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(other._RtsAppConnectionIdResponse);
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(other._RtsResponse);
    break;
  case Tag::RtsSdkProxyRequest:
    new(&(this->_RtsSdkProxyRequest)) Anki::Vector::ExternalComms::RtsSdkProxyRequest(other._RtsSdkProxyRequest);
    break;
  case Tag::RtsSdkProxyResponse:
    new(&(this->_RtsSdkProxyResponse)) Anki::Vector::ExternalComms::RtsSdkProxyResponse(other._RtsSdkProxyResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection_5& RtsConnection_5::operator=(RtsConnection_5&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse_3:
    new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(other._RtsWifiConnectResponse_3));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse_5:
    new(&(this->_RtsStatusResponse_5)) Anki::Vector::ExternalComms::RtsStatusResponse_5(std::move(other._RtsStatusResponse_5));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse_3:
    new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(other._RtsWifiScanResponse_3));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  case Tag::RtsOtaCancelRequest:
    new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(other._RtsOtaCancelRequest));
    break;
  case Tag::RtsLogRequest:
    new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(std::move(other._RtsLogRequest));
    break;
  case Tag::RtsLogResponse:
    new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(std::move(other._RtsLogResponse));
    break;
  case Tag::RtsFileDownload:
    new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(std::move(other._RtsFileDownload));
    break;
  case Tag::RtsWifiForgetRequest:
    new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(other._RtsWifiForgetRequest));
    break;
  case Tag::RtsWifiForgetResponse:
    new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(other._RtsWifiForgetResponse));
    break;
  case Tag::RtsCloudSessionRequest_2:
    new(&(this->_RtsCloudSessionRequest_2)) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(std::move(other._RtsCloudSessionRequest_2));
    break;
  case Tag::RtsCloudSessionResponse:
    new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(other._RtsCloudSessionResponse));
    break;
  case Tag::RtsAppConnectionIdRequest:
    new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(other._RtsAppConnectionIdRequest));
    break;
  case Tag::RtsAppConnectionIdResponse:
    new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(other._RtsAppConnectionIdResponse));
    break;
  case Tag::RtsResponse:
    new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(std::move(other._RtsResponse));
    break;
  case Tag::RtsSdkProxyRequest:
    new(&(this->_RtsSdkProxyRequest)) Anki::Vector::ExternalComms::RtsSdkProxyRequest(std::move(other._RtsSdkProxyRequest));
    break;
  case Tag::RtsSdkProxyResponse:
    new(&(this->_RtsSdkProxyResponse)) Anki::Vector::ExternalComms::RtsSdkProxyResponse(std::move(other._RtsSdkProxyResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection_5 RtsConnection_5::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection_5 m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection_5::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection_5::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection_5::Get_<RtsConnection_5::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection_5::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  RtsConnection_5 m;
  m.Set_RtsConnRequest(new_RtsConnRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
  _tag = Tag::RtsConnRequest;
}

const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_5::Get_RtsConnRequest() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

void RtsConnection_5::Set_RtsConnRequest(const Anki::Vector::ExternalComms::RtsConnRequest& new_RtsConnRequest)
{
  if(this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = new_RtsConnRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(new_RtsConnRequest);
    _tag = Tag::RtsConnRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsConnRequest>() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsConnRequest>(Anki::Vector::ExternalComms::RtsConnRequest member)
{
  return CreateRtsConnRequest(std::move(member));
}

void RtsConnection_5::Set_RtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  if (this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = std::move(new_RtsConnRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
    _tag = Tag::RtsConnRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  RtsConnection_5 m;
  m.Set_RtsConnResponse(new_RtsConnResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
  _tag = Tag::RtsConnResponse;
}

const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_5::Get_RtsConnResponse() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

void RtsConnection_5::Set_RtsConnResponse(const Anki::Vector::ExternalComms::RtsConnResponse& new_RtsConnResponse)
{
  if(this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = new_RtsConnResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(new_RtsConnResponse);
    _tag = Tag::RtsConnResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsConnResponse>() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsConnResponse>(Anki::Vector::ExternalComms::RtsConnResponse member)
{
  return CreateRtsConnResponse(std::move(member));
}

void RtsConnection_5::Set_RtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  if (this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = std::move(new_RtsConnResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
    _tag = Tag::RtsConnResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  RtsConnection_5 m;
  m.Set_RtsNonceMessage(new_RtsNonceMessage);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
  _tag = Tag::RtsNonceMessage;
}

const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_5::Get_RtsNonceMessage() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

void RtsConnection_5::Set_RtsNonceMessage(const Anki::Vector::ExternalComms::RtsNonceMessage& new_RtsNonceMessage)
{
  if(this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = new_RtsNonceMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(new_RtsNonceMessage);
    _tag = Tag::RtsNonceMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsNonceMessage>() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsNonceMessage>(Anki::Vector::ExternalComms::RtsNonceMessage member)
{
  return CreateRtsNonceMessage(std::move(member));
}

void RtsConnection_5::Set_RtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  if (this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = std::move(new_RtsNonceMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
    _tag = Tag::RtsNonceMessage;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  RtsConnection_5 m;
  m.Set_RtsChallengeMessage(new_RtsChallengeMessage);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
  _tag = Tag::RtsChallengeMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_5::Get_RtsChallengeMessage() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

void RtsConnection_5::Set_RtsChallengeMessage(const Anki::Vector::ExternalComms::RtsChallengeMessage& new_RtsChallengeMessage)
{
  if(this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = new_RtsChallengeMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(new_RtsChallengeMessage);
    _tag = Tag::RtsChallengeMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsChallengeMessage>() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsChallengeMessage>(Anki::Vector::ExternalComms::RtsChallengeMessage member)
{
  return CreateRtsChallengeMessage(std::move(member));
}

void RtsConnection_5::Set_RtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  if (this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = std::move(new_RtsChallengeMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
    _tag = Tag::RtsChallengeMessage;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  RtsConnection_5 m;
  m.Set_RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
  _tag = Tag::RtsChallengeSuccessMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_5::Get_RtsChallengeSuccessMessage() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

void RtsConnection_5::Set_RtsChallengeSuccessMessage(const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& new_RtsChallengeSuccessMessage)
{
  if(this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = new_RtsChallengeSuccessMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsChallengeSuccessMessage>() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsChallengeSuccessMessage>(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage member)
{
  return CreateRtsChallengeSuccessMessage(std::move(member));
}

void RtsConnection_5::Set_RtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  if (this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = std::move(new_RtsChallengeSuccessMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  RtsConnection_5 m;
  m.Set_RtsWifiConnectRequest(new_RtsWifiConnectRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
  _tag = Tag::RtsWifiConnectRequest;
}

const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_5::Get_RtsWifiConnectRequest() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

void RtsConnection_5::Set_RtsWifiConnectRequest(const Anki::Vector::ExternalComms::RtsWifiConnectRequest& new_RtsWifiConnectRequest)
{
  if(this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = new_RtsWifiConnectRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(new_RtsWifiConnectRequest);
    _tag = Tag::RtsWifiConnectRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiConnectRequest>() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiConnectRequest>(Anki::Vector::ExternalComms::RtsWifiConnectRequest member)
{
  return CreateRtsWifiConnectRequest(std::move(member));
}

void RtsConnection_5::Set_RtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  if (this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = std::move(new_RtsWifiConnectRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
    _tag = Tag::RtsWifiConnectRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  RtsConnection_5 m;
  m.Set_RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
  _tag = Tag::RtsWifiConnectResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_5::Get_RtsWifiConnectResponse_3() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

void RtsConnection_5::Set_RtsWifiConnectResponse_3(const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& new_RtsWifiConnectResponse_3)
{
  if(this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = new_RtsWifiConnectResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(new_RtsWifiConnectResponse_3);
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectResponse_3& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiConnectResponse_3>() const
{
  assert(_tag == Tag::RtsWifiConnectResponse_3);
  return this->_RtsWifiConnectResponse_3;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiConnectResponse_3>(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3 member)
{
  return CreateRtsWifiConnectResponse_3(std::move(member));
}

void RtsConnection_5::Set_RtsWifiConnectResponse_3(Anki::Vector::ExternalComms::RtsWifiConnectResponse_3&& new_RtsWifiConnectResponse_3)
{
  if (this->_tag == Tag::RtsWifiConnectResponse_3) {
    this->_RtsWifiConnectResponse_3 = std::move(new_RtsWifiConnectResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse_3) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(std::move(new_RtsWifiConnectResponse_3));
    _tag = Tag::RtsWifiConnectResponse_3;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  RtsConnection_5 m;
  m.Set_RtsWifiIpRequest(new_RtsWifiIpRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
  _tag = Tag::RtsWifiIpRequest;
}

const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_5::Get_RtsWifiIpRequest() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

void RtsConnection_5::Set_RtsWifiIpRequest(const Anki::Vector::ExternalComms::RtsWifiIpRequest& new_RtsWifiIpRequest)
{
  if(this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = new_RtsWifiIpRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(new_RtsWifiIpRequest);
    _tag = Tag::RtsWifiIpRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiIpRequest>() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiIpRequest>(Anki::Vector::ExternalComms::RtsWifiIpRequest member)
{
  return CreateRtsWifiIpRequest(std::move(member));
}

void RtsConnection_5::Set_RtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  if (this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = std::move(new_RtsWifiIpRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
    _tag = Tag::RtsWifiIpRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  RtsConnection_5 m;
  m.Set_RtsWifiIpResponse(new_RtsWifiIpResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
  _tag = Tag::RtsWifiIpResponse;
}

const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_5::Get_RtsWifiIpResponse() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

void RtsConnection_5::Set_RtsWifiIpResponse(const Anki::Vector::ExternalComms::RtsWifiIpResponse& new_RtsWifiIpResponse)
{
  if(this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = new_RtsWifiIpResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(new_RtsWifiIpResponse);
    _tag = Tag::RtsWifiIpResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiIpResponse>() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiIpResponse>(Anki::Vector::ExternalComms::RtsWifiIpResponse member)
{
  return CreateRtsWifiIpResponse(std::move(member));
}

void RtsConnection_5::Set_RtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  if (this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = std::move(new_RtsWifiIpResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
    _tag = Tag::RtsWifiIpResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  RtsConnection_5 m;
  m.Set_RtsStatusRequest(new_RtsStatusRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
  _tag = Tag::RtsStatusRequest;
}

const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_5::Get_RtsStatusRequest() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

void RtsConnection_5::Set_RtsStatusRequest(const Anki::Vector::ExternalComms::RtsStatusRequest& new_RtsStatusRequest)
{
  if(this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = new_RtsStatusRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(new_RtsStatusRequest);
    _tag = Tag::RtsStatusRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsStatusRequest>() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsStatusRequest>(Anki::Vector::ExternalComms::RtsStatusRequest member)
{
  return CreateRtsStatusRequest(std::move(member));
}

void RtsConnection_5::Set_RtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  if (this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = std::move(new_RtsStatusRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
    _tag = Tag::RtsStatusRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsStatusResponse_5(Anki::Vector::ExternalComms::RtsStatusResponse_5&& new_RtsStatusResponse_5)
{
  RtsConnection_5 m;
  m.Set_RtsStatusResponse_5(new_RtsStatusResponse_5);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsStatusResponse_5&& new_RtsStatusResponse_5)
{
  new(&this->_RtsStatusResponse_5) Anki::Vector::ExternalComms::RtsStatusResponse_5(std::move(new_RtsStatusResponse_5));
  _tag = Tag::RtsStatusResponse_5;
}

const Anki::Vector::ExternalComms::RtsStatusResponse_5& RtsConnection_5::Get_RtsStatusResponse_5() const
{
  assert(_tag == Tag::RtsStatusResponse_5);
  return this->_RtsStatusResponse_5;
}

void RtsConnection_5::Set_RtsStatusResponse_5(const Anki::Vector::ExternalComms::RtsStatusResponse_5& new_RtsStatusResponse_5)
{
  if(this->_tag == Tag::RtsStatusResponse_5) {
    this->_RtsStatusResponse_5 = new_RtsStatusResponse_5;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_5) Anki::Vector::ExternalComms::RtsStatusResponse_5(new_RtsStatusResponse_5);
    _tag = Tag::RtsStatusResponse_5;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusResponse_5& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsStatusResponse_5>() const
{
  assert(_tag == Tag::RtsStatusResponse_5);
  return this->_RtsStatusResponse_5;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsStatusResponse_5>(Anki::Vector::ExternalComms::RtsStatusResponse_5 member)
{
  return CreateRtsStatusResponse_5(std::move(member));
}

void RtsConnection_5::Set_RtsStatusResponse_5(Anki::Vector::ExternalComms::RtsStatusResponse_5&& new_RtsStatusResponse_5)
{
  if (this->_tag == Tag::RtsStatusResponse_5) {
    this->_RtsStatusResponse_5 = std::move(new_RtsStatusResponse_5);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse_5) Anki::Vector::ExternalComms::RtsStatusResponse_5(std::move(new_RtsStatusResponse_5));
    _tag = Tag::RtsStatusResponse_5;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  RtsConnection_5 m;
  m.Set_RtsWifiScanRequest(new_RtsWifiScanRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
  _tag = Tag::RtsWifiScanRequest;
}

const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_5::Get_RtsWifiScanRequest() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

void RtsConnection_5::Set_RtsWifiScanRequest(const Anki::Vector::ExternalComms::RtsWifiScanRequest& new_RtsWifiScanRequest)
{
  if(this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = new_RtsWifiScanRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(new_RtsWifiScanRequest);
    _tag = Tag::RtsWifiScanRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiScanRequest>() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiScanRequest>(Anki::Vector::ExternalComms::RtsWifiScanRequest member)
{
  return CreateRtsWifiScanRequest(std::move(member));
}

void RtsConnection_5::Set_RtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  if (this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = std::move(new_RtsWifiScanRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
    _tag = Tag::RtsWifiScanRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  RtsConnection_5 m;
  m.Set_RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
  _tag = Tag::RtsWifiScanResponse_3;
}

const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_5::Get_RtsWifiScanResponse_3() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

void RtsConnection_5::Set_RtsWifiScanResponse_3(const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& new_RtsWifiScanResponse_3)
{
  if(this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = new_RtsWifiScanResponse_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(new_RtsWifiScanResponse_3);
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanResponse_3& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiScanResponse_3>() const
{
  assert(_tag == Tag::RtsWifiScanResponse_3);
  return this->_RtsWifiScanResponse_3;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiScanResponse_3>(Anki::Vector::ExternalComms::RtsWifiScanResponse_3 member)
{
  return CreateRtsWifiScanResponse_3(std::move(member));
}

void RtsConnection_5::Set_RtsWifiScanResponse_3(Anki::Vector::ExternalComms::RtsWifiScanResponse_3&& new_RtsWifiScanResponse_3)
{
  if (this->_tag == Tag::RtsWifiScanResponse_3) {
    this->_RtsWifiScanResponse_3 = std::move(new_RtsWifiScanResponse_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse_3) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(std::move(new_RtsWifiScanResponse_3));
    _tag = Tag::RtsWifiScanResponse_3;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  RtsConnection_5 m;
  m.Set_RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
  _tag = Tag::RtsOtaUpdateRequest;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_5::Get_RtsOtaUpdateRequest() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

void RtsConnection_5::Set_RtsOtaUpdateRequest(const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& new_RtsOtaUpdateRequest)
{
  if(this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = new_RtsOtaUpdateRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsOtaUpdateRequest>() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsOtaUpdateRequest>(Anki::Vector::ExternalComms::RtsOtaUpdateRequest member)
{
  return CreateRtsOtaUpdateRequest(std::move(member));
}

void RtsConnection_5::Set_RtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  if (this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = std::move(new_RtsOtaUpdateRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  RtsConnection_5 m;
  m.Set_RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
  _tag = Tag::RtsOtaUpdateResponse;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_5::Get_RtsOtaUpdateResponse() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

void RtsConnection_5::Set_RtsOtaUpdateResponse(const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& new_RtsOtaUpdateResponse)
{
  if(this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = new_RtsOtaUpdateResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsOtaUpdateResponse>() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsOtaUpdateResponse>(Anki::Vector::ExternalComms::RtsOtaUpdateResponse member)
{
  return CreateRtsOtaUpdateResponse(std::move(member));
}

void RtsConnection_5::Set_RtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  if (this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = std::move(new_RtsOtaUpdateResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  RtsConnection_5 m;
  m.Set_RtsCancelPairing(new_RtsCancelPairing);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
  _tag = Tag::RtsCancelPairing;
}

const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_5::Get_RtsCancelPairing() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

void RtsConnection_5::Set_RtsCancelPairing(const Anki::Vector::ExternalComms::RtsCancelPairing& new_RtsCancelPairing)
{
  if(this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = new_RtsCancelPairing;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(new_RtsCancelPairing);
    _tag = Tag::RtsCancelPairing;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsCancelPairing>() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsCancelPairing>(Anki::Vector::ExternalComms::RtsCancelPairing member)
{
  return CreateRtsCancelPairing(std::move(member));
}

void RtsConnection_5::Set_RtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  if (this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = std::move(new_RtsCancelPairing);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
    _tag = Tag::RtsCancelPairing;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  RtsConnection_5 m;
  m.Set_RtsForceDisconnect(new_RtsForceDisconnect);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
  _tag = Tag::RtsForceDisconnect;
}

const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_5::Get_RtsForceDisconnect() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

void RtsConnection_5::Set_RtsForceDisconnect(const Anki::Vector::ExternalComms::RtsForceDisconnect& new_RtsForceDisconnect)
{
  if(this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = new_RtsForceDisconnect;
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(new_RtsForceDisconnect);
    _tag = Tag::RtsForceDisconnect;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsForceDisconnect>() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsForceDisconnect>(Anki::Vector::ExternalComms::RtsForceDisconnect member)
{
  return CreateRtsForceDisconnect(std::move(member));
}

void RtsConnection_5::Set_RtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  if (this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = std::move(new_RtsForceDisconnect);
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
    _tag = Tag::RtsForceDisconnect;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  RtsConnection_5 m;
  m.Set_RtsAck(new_RtsAck);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
  _tag = Tag::RtsAck;
}

const Anki::Vector::ExternalComms::RtsAck& RtsConnection_5::Get_RtsAck() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

void RtsConnection_5::Set_RtsAck(const Anki::Vector::ExternalComms::RtsAck& new_RtsAck)
{
  if(this->_tag == Tag::RtsAck) {
    this->_RtsAck = new_RtsAck;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(new_RtsAck);
    _tag = Tag::RtsAck;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAck& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsAck>() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsAck>(Anki::Vector::ExternalComms::RtsAck member)
{
  return CreateRtsAck(std::move(member));
}

void RtsConnection_5::Set_RtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  if (this->_tag == Tag::RtsAck) {
    this->_RtsAck = std::move(new_RtsAck);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
    _tag = Tag::RtsAck;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  RtsConnection_5 m;
  m.Set_RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
  _tag = Tag::RtsWifiAccessPointRequest;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_5::Get_RtsWifiAccessPointRequest() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

void RtsConnection_5::Set_RtsWifiAccessPointRequest(const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& new_RtsWifiAccessPointRequest)
{
  if(this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = new_RtsWifiAccessPointRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiAccessPointRequest>() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiAccessPointRequest>(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest member)
{
  return CreateRtsWifiAccessPointRequest(std::move(member));
}

void RtsConnection_5::Set_RtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  if (this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = std::move(new_RtsWifiAccessPointRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  RtsConnection_5 m;
  m.Set_RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
  _tag = Tag::RtsWifiAccessPointResponse;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_5::Get_RtsWifiAccessPointResponse() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

void RtsConnection_5::Set_RtsWifiAccessPointResponse(const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& new_RtsWifiAccessPointResponse)
{
  if(this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = new_RtsWifiAccessPointResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiAccessPointResponse>() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiAccessPointResponse>(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse member)
{
  return CreateRtsWifiAccessPointResponse(std::move(member));
}

void RtsConnection_5::Set_RtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  if (this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = std::move(new_RtsWifiAccessPointResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  RtsConnection_5 m;
  m.Set_RtsSshRequest(new_RtsSshRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
  _tag = Tag::RtsSshRequest;
}

const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_5::Get_RtsSshRequest() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

void RtsConnection_5::Set_RtsSshRequest(const Anki::Vector::ExternalComms::RtsSshRequest& new_RtsSshRequest)
{
  if(this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = new_RtsSshRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(new_RtsSshRequest);
    _tag = Tag::RtsSshRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsSshRequest>() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsSshRequest>(Anki::Vector::ExternalComms::RtsSshRequest member)
{
  return CreateRtsSshRequest(std::move(member));
}

void RtsConnection_5::Set_RtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  if (this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = std::move(new_RtsSshRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
    _tag = Tag::RtsSshRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  RtsConnection_5 m;
  m.Set_RtsSshResponse(new_RtsSshResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
  _tag = Tag::RtsSshResponse;
}

const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_5::Get_RtsSshResponse() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

void RtsConnection_5::Set_RtsSshResponse(const Anki::Vector::ExternalComms::RtsSshResponse& new_RtsSshResponse)
{
  if(this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = new_RtsSshResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(new_RtsSshResponse);
    _tag = Tag::RtsSshResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsSshResponse>() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsSshResponse>(Anki::Vector::ExternalComms::RtsSshResponse member)
{
  return CreateRtsSshResponse(std::move(member));
}

void RtsConnection_5::Set_RtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  if (this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = std::move(new_RtsSshResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
    _tag = Tag::RtsSshResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  RtsConnection_5 m;
  m.Set_RtsOtaCancelRequest(new_RtsOtaCancelRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
  _tag = Tag::RtsOtaCancelRequest;
}

const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_5::Get_RtsOtaCancelRequest() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

void RtsConnection_5::Set_RtsOtaCancelRequest(const Anki::Vector::ExternalComms::RtsOtaCancelRequest& new_RtsOtaCancelRequest)
{
  if(this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = new_RtsOtaCancelRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(new_RtsOtaCancelRequest);
    _tag = Tag::RtsOtaCancelRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaCancelRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsOtaCancelRequest>() const
{
  assert(_tag == Tag::RtsOtaCancelRequest);
  return this->_RtsOtaCancelRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsOtaCancelRequest>(Anki::Vector::ExternalComms::RtsOtaCancelRequest member)
{
  return CreateRtsOtaCancelRequest(std::move(member));
}

void RtsConnection_5::Set_RtsOtaCancelRequest(Anki::Vector::ExternalComms::RtsOtaCancelRequest&& new_RtsOtaCancelRequest)
{
  if (this->_tag == Tag::RtsOtaCancelRequest) {
    this->_RtsOtaCancelRequest = std::move(new_RtsOtaCancelRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaCancelRequest) Anki::Vector::ExternalComms::RtsOtaCancelRequest(std::move(new_RtsOtaCancelRequest));
    _tag = Tag::RtsOtaCancelRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  RtsConnection_5 m;
  m.Set_RtsLogRequest(new_RtsLogRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
  _tag = Tag::RtsLogRequest;
}

const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_5::Get_RtsLogRequest() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

void RtsConnection_5::Set_RtsLogRequest(const Anki::Vector::ExternalComms::RtsLogRequest& new_RtsLogRequest)
{
  if(this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = new_RtsLogRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(new_RtsLogRequest);
    _tag = Tag::RtsLogRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsLogRequest>() const
{
  assert(_tag == Tag::RtsLogRequest);
  return this->_RtsLogRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsLogRequest>(Anki::Vector::ExternalComms::RtsLogRequest member)
{
  return CreateRtsLogRequest(std::move(member));
}

void RtsConnection_5::Set_RtsLogRequest(Anki::Vector::ExternalComms::RtsLogRequest&& new_RtsLogRequest)
{
  if (this->_tag == Tag::RtsLogRequest) {
    this->_RtsLogRequest = std::move(new_RtsLogRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogRequest) Anki::Vector::ExternalComms::RtsLogRequest(std::move(new_RtsLogRequest));
    _tag = Tag::RtsLogRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  RtsConnection_5 m;
  m.Set_RtsLogResponse(new_RtsLogResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
  _tag = Tag::RtsLogResponse;
}

const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_5::Get_RtsLogResponse() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

void RtsConnection_5::Set_RtsLogResponse(const Anki::Vector::ExternalComms::RtsLogResponse& new_RtsLogResponse)
{
  if(this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = new_RtsLogResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(new_RtsLogResponse);
    _tag = Tag::RtsLogResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsLogResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsLogResponse>() const
{
  assert(_tag == Tag::RtsLogResponse);
  return this->_RtsLogResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsLogResponse>(Anki::Vector::ExternalComms::RtsLogResponse member)
{
  return CreateRtsLogResponse(std::move(member));
}

void RtsConnection_5::Set_RtsLogResponse(Anki::Vector::ExternalComms::RtsLogResponse&& new_RtsLogResponse)
{
  if (this->_tag == Tag::RtsLogResponse) {
    this->_RtsLogResponse = std::move(new_RtsLogResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsLogResponse) Anki::Vector::ExternalComms::RtsLogResponse(std::move(new_RtsLogResponse));
    _tag = Tag::RtsLogResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  RtsConnection_5 m;
  m.Set_RtsFileDownload(new_RtsFileDownload);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
  _tag = Tag::RtsFileDownload;
}

const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_5::Get_RtsFileDownload() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

void RtsConnection_5::Set_RtsFileDownload(const Anki::Vector::ExternalComms::RtsFileDownload& new_RtsFileDownload)
{
  if(this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = new_RtsFileDownload;
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(new_RtsFileDownload);
    _tag = Tag::RtsFileDownload;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsFileDownload& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsFileDownload>() const
{
  assert(_tag == Tag::RtsFileDownload);
  return this->_RtsFileDownload;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsFileDownload>(Anki::Vector::ExternalComms::RtsFileDownload member)
{
  return CreateRtsFileDownload(std::move(member));
}

void RtsConnection_5::Set_RtsFileDownload(Anki::Vector::ExternalComms::RtsFileDownload&& new_RtsFileDownload)
{
  if (this->_tag == Tag::RtsFileDownload) {
    this->_RtsFileDownload = std::move(new_RtsFileDownload);
  }
  else {
    ClearCurrent();
    new(&this->_RtsFileDownload) Anki::Vector::ExternalComms::RtsFileDownload(std::move(new_RtsFileDownload));
    _tag = Tag::RtsFileDownload;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  RtsConnection_5 m;
  m.Set_RtsWifiForgetRequest(new_RtsWifiForgetRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
  _tag = Tag::RtsWifiForgetRequest;
}

const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_5::Get_RtsWifiForgetRequest() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

void RtsConnection_5::Set_RtsWifiForgetRequest(const Anki::Vector::ExternalComms::RtsWifiForgetRequest& new_RtsWifiForgetRequest)
{
  if(this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = new_RtsWifiForgetRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(new_RtsWifiForgetRequest);
    _tag = Tag::RtsWifiForgetRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiForgetRequest>() const
{
  assert(_tag == Tag::RtsWifiForgetRequest);
  return this->_RtsWifiForgetRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiForgetRequest>(Anki::Vector::ExternalComms::RtsWifiForgetRequest member)
{
  return CreateRtsWifiForgetRequest(std::move(member));
}

void RtsConnection_5::Set_RtsWifiForgetRequest(Anki::Vector::ExternalComms::RtsWifiForgetRequest&& new_RtsWifiForgetRequest)
{
  if (this->_tag == Tag::RtsWifiForgetRequest) {
    this->_RtsWifiForgetRequest = std::move(new_RtsWifiForgetRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetRequest) Anki::Vector::ExternalComms::RtsWifiForgetRequest(std::move(new_RtsWifiForgetRequest));
    _tag = Tag::RtsWifiForgetRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  RtsConnection_5 m;
  m.Set_RtsWifiForgetResponse(new_RtsWifiForgetResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
  _tag = Tag::RtsWifiForgetResponse;
}

const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_5::Get_RtsWifiForgetResponse() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

void RtsConnection_5::Set_RtsWifiForgetResponse(const Anki::Vector::ExternalComms::RtsWifiForgetResponse& new_RtsWifiForgetResponse)
{
  if(this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = new_RtsWifiForgetResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(new_RtsWifiForgetResponse);
    _tag = Tag::RtsWifiForgetResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiForgetResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsWifiForgetResponse>() const
{
  assert(_tag == Tag::RtsWifiForgetResponse);
  return this->_RtsWifiForgetResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsWifiForgetResponse>(Anki::Vector::ExternalComms::RtsWifiForgetResponse member)
{
  return CreateRtsWifiForgetResponse(std::move(member));
}

void RtsConnection_5::Set_RtsWifiForgetResponse(Anki::Vector::ExternalComms::RtsWifiForgetResponse&& new_RtsWifiForgetResponse)
{
  if (this->_tag == Tag::RtsWifiForgetResponse) {
    this->_RtsWifiForgetResponse = std::move(new_RtsWifiForgetResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiForgetResponse) Anki::Vector::ExternalComms::RtsWifiForgetResponse(std::move(new_RtsWifiForgetResponse));
    _tag = Tag::RtsWifiForgetResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsCloudSessionRequest_2(Anki::Vector::ExternalComms::RtsCloudSessionRequest_2&& new_RtsCloudSessionRequest_2)
{
  RtsConnection_5 m;
  m.Set_RtsCloudSessionRequest_2(new_RtsCloudSessionRequest_2);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsCloudSessionRequest_2&& new_RtsCloudSessionRequest_2)
{
  new(&this->_RtsCloudSessionRequest_2) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(std::move(new_RtsCloudSessionRequest_2));
  _tag = Tag::RtsCloudSessionRequest_2;
}

const Anki::Vector::ExternalComms::RtsCloudSessionRequest_2& RtsConnection_5::Get_RtsCloudSessionRequest_2() const
{
  assert(_tag == Tag::RtsCloudSessionRequest_2);
  return this->_RtsCloudSessionRequest_2;
}

void RtsConnection_5::Set_RtsCloudSessionRequest_2(const Anki::Vector::ExternalComms::RtsCloudSessionRequest_2& new_RtsCloudSessionRequest_2)
{
  if(this->_tag == Tag::RtsCloudSessionRequest_2) {
    this->_RtsCloudSessionRequest_2 = new_RtsCloudSessionRequest_2;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest_2) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(new_RtsCloudSessionRequest_2);
    _tag = Tag::RtsCloudSessionRequest_2;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionRequest_2& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsCloudSessionRequest_2>() const
{
  assert(_tag == Tag::RtsCloudSessionRequest_2);
  return this->_RtsCloudSessionRequest_2;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsCloudSessionRequest_2>(Anki::Vector::ExternalComms::RtsCloudSessionRequest_2 member)
{
  return CreateRtsCloudSessionRequest_2(std::move(member));
}

void RtsConnection_5::Set_RtsCloudSessionRequest_2(Anki::Vector::ExternalComms::RtsCloudSessionRequest_2&& new_RtsCloudSessionRequest_2)
{
  if (this->_tag == Tag::RtsCloudSessionRequest_2) {
    this->_RtsCloudSessionRequest_2 = std::move(new_RtsCloudSessionRequest_2);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionRequest_2) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(std::move(new_RtsCloudSessionRequest_2));
    _tag = Tag::RtsCloudSessionRequest_2;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  RtsConnection_5 m;
  m.Set_RtsCloudSessionResponse(new_RtsCloudSessionResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
  _tag = Tag::RtsCloudSessionResponse;
}

const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_5::Get_RtsCloudSessionResponse() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

void RtsConnection_5::Set_RtsCloudSessionResponse(const Anki::Vector::ExternalComms::RtsCloudSessionResponse& new_RtsCloudSessionResponse)
{
  if(this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = new_RtsCloudSessionResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(new_RtsCloudSessionResponse);
    _tag = Tag::RtsCloudSessionResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCloudSessionResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsCloudSessionResponse>() const
{
  assert(_tag == Tag::RtsCloudSessionResponse);
  return this->_RtsCloudSessionResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsCloudSessionResponse>(Anki::Vector::ExternalComms::RtsCloudSessionResponse member)
{
  return CreateRtsCloudSessionResponse(std::move(member));
}

void RtsConnection_5::Set_RtsCloudSessionResponse(Anki::Vector::ExternalComms::RtsCloudSessionResponse&& new_RtsCloudSessionResponse)
{
  if (this->_tag == Tag::RtsCloudSessionResponse) {
    this->_RtsCloudSessionResponse = std::move(new_RtsCloudSessionResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCloudSessionResponse) Anki::Vector::ExternalComms::RtsCloudSessionResponse(std::move(new_RtsCloudSessionResponse));
    _tag = Tag::RtsCloudSessionResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsAppConnectionIdRequest(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  RtsConnection_5 m;
  m.Set_RtsAppConnectionIdRequest(new_RtsAppConnectionIdRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(new_RtsAppConnectionIdRequest));
  _tag = Tag::RtsAppConnectionIdRequest;
}

const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& RtsConnection_5::Get_RtsAppConnectionIdRequest() const
{
  assert(_tag == Tag::RtsAppConnectionIdRequest);
  return this->_RtsAppConnectionIdRequest;
}

void RtsConnection_5::Set_RtsAppConnectionIdRequest(const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& new_RtsAppConnectionIdRequest)
{
  if(this->_tag == Tag::RtsAppConnectionIdRequest) {
    this->_RtsAppConnectionIdRequest = new_RtsAppConnectionIdRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(new_RtsAppConnectionIdRequest);
    _tag = Tag::RtsAppConnectionIdRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAppConnectionIdRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsAppConnectionIdRequest>() const
{
  assert(_tag == Tag::RtsAppConnectionIdRequest);
  return this->_RtsAppConnectionIdRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsAppConnectionIdRequest>(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest member)
{
  return CreateRtsAppConnectionIdRequest(std::move(member));
}

void RtsConnection_5::Set_RtsAppConnectionIdRequest(Anki::Vector::ExternalComms::RtsAppConnectionIdRequest&& new_RtsAppConnectionIdRequest)
{
  if (this->_tag == Tag::RtsAppConnectionIdRequest) {
    this->_RtsAppConnectionIdRequest = std::move(new_RtsAppConnectionIdRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdRequest) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(std::move(new_RtsAppConnectionIdRequest));
    _tag = Tag::RtsAppConnectionIdRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsAppConnectionIdResponse(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  RtsConnection_5 m;
  m.Set_RtsAppConnectionIdResponse(new_RtsAppConnectionIdResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(new_RtsAppConnectionIdResponse));
  _tag = Tag::RtsAppConnectionIdResponse;
}

const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& RtsConnection_5::Get_RtsAppConnectionIdResponse() const
{
  assert(_tag == Tag::RtsAppConnectionIdResponse);
  return this->_RtsAppConnectionIdResponse;
}

void RtsConnection_5::Set_RtsAppConnectionIdResponse(const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& new_RtsAppConnectionIdResponse)
{
  if(this->_tag == Tag::RtsAppConnectionIdResponse) {
    this->_RtsAppConnectionIdResponse = new_RtsAppConnectionIdResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(new_RtsAppConnectionIdResponse);
    _tag = Tag::RtsAppConnectionIdResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAppConnectionIdResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsAppConnectionIdResponse>() const
{
  assert(_tag == Tag::RtsAppConnectionIdResponse);
  return this->_RtsAppConnectionIdResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsAppConnectionIdResponse>(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse member)
{
  return CreateRtsAppConnectionIdResponse(std::move(member));
}

void RtsConnection_5::Set_RtsAppConnectionIdResponse(Anki::Vector::ExternalComms::RtsAppConnectionIdResponse&& new_RtsAppConnectionIdResponse)
{
  if (this->_tag == Tag::RtsAppConnectionIdResponse) {
    this->_RtsAppConnectionIdResponse = std::move(new_RtsAppConnectionIdResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAppConnectionIdResponse) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(std::move(new_RtsAppConnectionIdResponse));
    _tag = Tag::RtsAppConnectionIdResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsResponse(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  RtsConnection_5 m;
  m.Set_RtsResponse(new_RtsResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(std::move(new_RtsResponse));
  _tag = Tag::RtsResponse;
}

const Anki::Vector::ExternalComms::RtsResponse& RtsConnection_5::Get_RtsResponse() const
{
  assert(_tag == Tag::RtsResponse);
  return this->_RtsResponse;
}

void RtsConnection_5::Set_RtsResponse(const Anki::Vector::ExternalComms::RtsResponse& new_RtsResponse)
{
  if(this->_tag == Tag::RtsResponse) {
    this->_RtsResponse = new_RtsResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(new_RtsResponse);
    _tag = Tag::RtsResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsResponse>() const
{
  assert(_tag == Tag::RtsResponse);
  return this->_RtsResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsResponse>(Anki::Vector::ExternalComms::RtsResponse member)
{
  return CreateRtsResponse(std::move(member));
}

void RtsConnection_5::Set_RtsResponse(Anki::Vector::ExternalComms::RtsResponse&& new_RtsResponse)
{
  if (this->_tag == Tag::RtsResponse) {
    this->_RtsResponse = std::move(new_RtsResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsResponse) Anki::Vector::ExternalComms::RtsResponse(std::move(new_RtsResponse));
    _tag = Tag::RtsResponse;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsSdkProxyRequest(Anki::Vector::ExternalComms::RtsSdkProxyRequest&& new_RtsSdkProxyRequest)
{
  RtsConnection_5 m;
  m.Set_RtsSdkProxyRequest(new_RtsSdkProxyRequest);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsSdkProxyRequest&& new_RtsSdkProxyRequest)
{
  new(&this->_RtsSdkProxyRequest) Anki::Vector::ExternalComms::RtsSdkProxyRequest(std::move(new_RtsSdkProxyRequest));
  _tag = Tag::RtsSdkProxyRequest;
}

const Anki::Vector::ExternalComms::RtsSdkProxyRequest& RtsConnection_5::Get_RtsSdkProxyRequest() const
{
  assert(_tag == Tag::RtsSdkProxyRequest);
  return this->_RtsSdkProxyRequest;
}

void RtsConnection_5::Set_RtsSdkProxyRequest(const Anki::Vector::ExternalComms::RtsSdkProxyRequest& new_RtsSdkProxyRequest)
{
  if(this->_tag == Tag::RtsSdkProxyRequest) {
    this->_RtsSdkProxyRequest = new_RtsSdkProxyRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSdkProxyRequest) Anki::Vector::ExternalComms::RtsSdkProxyRequest(new_RtsSdkProxyRequest);
    _tag = Tag::RtsSdkProxyRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSdkProxyRequest& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsSdkProxyRequest>() const
{
  assert(_tag == Tag::RtsSdkProxyRequest);
  return this->_RtsSdkProxyRequest;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsSdkProxyRequest>(Anki::Vector::ExternalComms::RtsSdkProxyRequest member)
{
  return CreateRtsSdkProxyRequest(std::move(member));
}

void RtsConnection_5::Set_RtsSdkProxyRequest(Anki::Vector::ExternalComms::RtsSdkProxyRequest&& new_RtsSdkProxyRequest)
{
  if (this->_tag == Tag::RtsSdkProxyRequest) {
    this->_RtsSdkProxyRequest = std::move(new_RtsSdkProxyRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSdkProxyRequest) Anki::Vector::ExternalComms::RtsSdkProxyRequest(std::move(new_RtsSdkProxyRequest));
    _tag = Tag::RtsSdkProxyRequest;
  }
}

RtsConnection_5 RtsConnection_5::CreateRtsSdkProxyResponse(Anki::Vector::ExternalComms::RtsSdkProxyResponse&& new_RtsSdkProxyResponse)
{
  RtsConnection_5 m;
  m.Set_RtsSdkProxyResponse(new_RtsSdkProxyResponse);
  return m;
}

RtsConnection_5::RtsConnection_5(Anki::Vector::ExternalComms::RtsSdkProxyResponse&& new_RtsSdkProxyResponse)
{
  new(&this->_RtsSdkProxyResponse) Anki::Vector::ExternalComms::RtsSdkProxyResponse(std::move(new_RtsSdkProxyResponse));
  _tag = Tag::RtsSdkProxyResponse;
}

const Anki::Vector::ExternalComms::RtsSdkProxyResponse& RtsConnection_5::Get_RtsSdkProxyResponse() const
{
  assert(_tag == Tag::RtsSdkProxyResponse);
  return this->_RtsSdkProxyResponse;
}

void RtsConnection_5::Set_RtsSdkProxyResponse(const Anki::Vector::ExternalComms::RtsSdkProxyResponse& new_RtsSdkProxyResponse)
{
  if(this->_tag == Tag::RtsSdkProxyResponse) {
    this->_RtsSdkProxyResponse = new_RtsSdkProxyResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSdkProxyResponse) Anki::Vector::ExternalComms::RtsSdkProxyResponse(new_RtsSdkProxyResponse);
    _tag = Tag::RtsSdkProxyResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSdkProxyResponse& RtsConnection_5::Get_<RtsConnection_5::Tag::RtsSdkProxyResponse>() const
{
  assert(_tag == Tag::RtsSdkProxyResponse);
  return this->_RtsSdkProxyResponse;
}

template<>
RtsConnection_5 RtsConnection_5::Create_<RtsConnection_5::Tag::RtsSdkProxyResponse>(Anki::Vector::ExternalComms::RtsSdkProxyResponse member)
{
  return CreateRtsSdkProxyResponse(std::move(member));
}

void RtsConnection_5::Set_RtsSdkProxyResponse(Anki::Vector::ExternalComms::RtsSdkProxyResponse&& new_RtsSdkProxyResponse)
{
  if (this->_tag == Tag::RtsSdkProxyResponse) {
    this->_RtsSdkProxyResponse = std::move(new_RtsSdkProxyResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSdkProxyResponse) Anki::Vector::ExternalComms::RtsSdkProxyResponse(std::move(new_RtsSdkProxyResponse));
    _tag = Tag::RtsSdkProxyResponse;
  }
}

size_t RtsConnection_5::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection_5::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(buffer);
    }
    else {
      this->_RtsConnRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsConnResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(buffer);
    }
    else {
      this->_RtsConnResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsNonceMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(buffer);
    }
    else {
      this->_RtsNonceMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(buffer);
    }
    else {
      this->_RtsChallengeMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeSuccessMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(buffer);
    }
    else {
      this->_RtsChallengeSuccessMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(buffer);
    }
    else {
      this->_RtsWifiConnectRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectResponse_3)) Anki::Vector::ExternalComms::RtsWifiConnectResponse_3(buffer);
    }
    else {
      this->_RtsWifiConnectResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(buffer);
    }
    else {
      this->_RtsWifiIpRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(buffer);
    }
    else {
      this->_RtsWifiIpResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(buffer);
    }
    else {
      this->_RtsStatusRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusResponse_5:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusResponse_5)) Anki::Vector::ExternalComms::RtsStatusResponse_5(buffer);
    }
    else {
      this->_RtsStatusResponse_5.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(buffer);
    }
    else {
      this->_RtsWifiScanRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanResponse_3:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanResponse_3)) Anki::Vector::ExternalComms::RtsWifiScanResponse_3(buffer);
    }
    else {
      this->_RtsWifiScanResponse_3.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(buffer);
    }
    else {
      this->_RtsOtaUpdateRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(buffer);
    }
    else {
      this->_RtsOtaUpdateResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCancelPairing:
    if (newTag != oldTag) {
      new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(buffer);
    }
    else {
      this->_RtsCancelPairing.Unpack(buffer);
    }
    break;
  case Tag::RtsForceDisconnect:
    if (newTag != oldTag) {
      new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(buffer);
    }
    else {
      this->_RtsForceDisconnect.Unpack(buffer);
    }
    break;
  case Tag::RtsAck:
    if (newTag != oldTag) {
      new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(buffer);
    }
    else {
      this->_RtsAck.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(buffer);
    }
    else {
      this->_RtsWifiAccessPointRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(buffer);
    }
    else {
      this->_RtsWifiAccessPointResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSshRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(buffer);
    }
    else {
      this->_RtsSshRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSshResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(buffer);
    }
    else {
      this->_RtsSshResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaCancelRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaCancelRequest)) Anki::Vector::ExternalComms::RtsOtaCancelRequest(buffer);
    }
    else {
      this->_RtsOtaCancelRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsLogRequest)) Anki::Vector::ExternalComms::RtsLogRequest(buffer);
    }
    else {
      this->_RtsLogRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsLogResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsLogResponse)) Anki::Vector::ExternalComms::RtsLogResponse(buffer);
    }
    else {
      this->_RtsLogResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsFileDownload:
    if (newTag != oldTag) {
      new(&(this->_RtsFileDownload)) Anki::Vector::ExternalComms::RtsFileDownload(buffer);
    }
    else {
      this->_RtsFileDownload.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetRequest)) Anki::Vector::ExternalComms::RtsWifiForgetRequest(buffer);
    }
    else {
      this->_RtsWifiForgetRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiForgetResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiForgetResponse)) Anki::Vector::ExternalComms::RtsWifiForgetResponse(buffer);
    }
    else {
      this->_RtsWifiForgetResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionRequest_2:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionRequest_2)) Anki::Vector::ExternalComms::RtsCloudSessionRequest_2(buffer);
    }
    else {
      this->_RtsCloudSessionRequest_2.Unpack(buffer);
    }
    break;
  case Tag::RtsCloudSessionResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsCloudSessionResponse)) Anki::Vector::ExternalComms::RtsCloudSessionResponse(buffer);
    }
    else {
      this->_RtsCloudSessionResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsAppConnectionIdRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsAppConnectionIdRequest)) Anki::Vector::ExternalComms::RtsAppConnectionIdRequest(buffer);
    }
    else {
      this->_RtsAppConnectionIdRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsAppConnectionIdResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsAppConnectionIdResponse)) Anki::Vector::ExternalComms::RtsAppConnectionIdResponse(buffer);
    }
    else {
      this->_RtsAppConnectionIdResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsResponse)) Anki::Vector::ExternalComms::RtsResponse(buffer);
    }
    else {
      this->_RtsResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSdkProxyRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSdkProxyRequest)) Anki::Vector::ExternalComms::RtsSdkProxyRequest(buffer);
    }
    else {
      this->_RtsSdkProxyRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSdkProxyResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSdkProxyResponse)) Anki::Vector::ExternalComms::RtsSdkProxyResponse(buffer);
    }
    else {
      this->_RtsSdkProxyResponse.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection_5::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection_5::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnRequest:
    this->_RtsConnRequest.Pack(buffer);
    break;
  case Tag::RtsConnResponse:
    this->_RtsConnResponse.Pack(buffer);
    break;
  case Tag::RtsNonceMessage:
    this->_RtsNonceMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeMessage:
    this->_RtsChallengeMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeSuccessMessage:
    this->_RtsChallengeSuccessMessage.Pack(buffer);
    break;
  case Tag::RtsWifiConnectRequest:
    this->_RtsWifiConnectRequest.Pack(buffer);
    break;
  case Tag::RtsWifiConnectResponse_3:
    this->_RtsWifiConnectResponse_3.Pack(buffer);
    break;
  case Tag::RtsWifiIpRequest:
    this->_RtsWifiIpRequest.Pack(buffer);
    break;
  case Tag::RtsWifiIpResponse:
    this->_RtsWifiIpResponse.Pack(buffer);
    break;
  case Tag::RtsStatusRequest:
    this->_RtsStatusRequest.Pack(buffer);
    break;
  case Tag::RtsStatusResponse_5:
    this->_RtsStatusResponse_5.Pack(buffer);
    break;
  case Tag::RtsWifiScanRequest:
    this->_RtsWifiScanRequest.Pack(buffer);
    break;
  case Tag::RtsWifiScanResponse_3:
    this->_RtsWifiScanResponse_3.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateRequest:
    this->_RtsOtaUpdateRequest.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateResponse:
    this->_RtsOtaUpdateResponse.Pack(buffer);
    break;
  case Tag::RtsCancelPairing:
    this->_RtsCancelPairing.Pack(buffer);
    break;
  case Tag::RtsForceDisconnect:
    this->_RtsForceDisconnect.Pack(buffer);
    break;
  case Tag::RtsAck:
    this->_RtsAck.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointRequest:
    this->_RtsWifiAccessPointRequest.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointResponse:
    this->_RtsWifiAccessPointResponse.Pack(buffer);
    break;
  case Tag::RtsSshRequest:
    this->_RtsSshRequest.Pack(buffer);
    break;
  case Tag::RtsSshResponse:
    this->_RtsSshResponse.Pack(buffer);
    break;
  case Tag::RtsOtaCancelRequest:
    this->_RtsOtaCancelRequest.Pack(buffer);
    break;
  case Tag::RtsLogRequest:
    this->_RtsLogRequest.Pack(buffer);
    break;
  case Tag::RtsLogResponse:
    this->_RtsLogResponse.Pack(buffer);
    break;
  case Tag::RtsFileDownload:
    this->_RtsFileDownload.Pack(buffer);
    break;
  case Tag::RtsWifiForgetRequest:
    this->_RtsWifiForgetRequest.Pack(buffer);
    break;
  case Tag::RtsWifiForgetResponse:
    this->_RtsWifiForgetResponse.Pack(buffer);
    break;
  case Tag::RtsCloudSessionRequest_2:
    this->_RtsCloudSessionRequest_2.Pack(buffer);
    break;
  case Tag::RtsCloudSessionResponse:
    this->_RtsCloudSessionResponse.Pack(buffer);
    break;
  case Tag::RtsAppConnectionIdRequest:
    this->_RtsAppConnectionIdRequest.Pack(buffer);
    break;
  case Tag::RtsAppConnectionIdResponse:
    this->_RtsAppConnectionIdResponse.Pack(buffer);
    break;
  case Tag::RtsResponse:
    this->_RtsResponse.Pack(buffer);
    break;
  case Tag::RtsSdkProxyRequest:
    this->_RtsSdkProxyRequest.Pack(buffer);
    break;
  case Tag::RtsSdkProxyResponse:
    this->_RtsSdkProxyResponse.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection_5::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnRequest:
    result += this->_RtsConnRequest.Size(); // RtsConnRequest
    break;
  case Tag::RtsConnResponse:
    result += this->_RtsConnResponse.Size(); // RtsConnResponse
    break;
  case Tag::RtsNonceMessage:
    result += this->_RtsNonceMessage.Size(); // RtsNonceMessage
    break;
  case Tag::RtsChallengeMessage:
    result += this->_RtsChallengeMessage.Size(); // RtsChallengeMessage
    break;
  case Tag::RtsChallengeSuccessMessage:
    result += this->_RtsChallengeSuccessMessage.Size(); // RtsChallengeSuccessMessage
    break;
  case Tag::RtsWifiConnectRequest:
    result += this->_RtsWifiConnectRequest.Size(); // RtsWifiConnectRequest
    break;
  case Tag::RtsWifiConnectResponse_3:
    result += this->_RtsWifiConnectResponse_3.Size(); // RtsWifiConnectResponse_3
    break;
  case Tag::RtsWifiIpRequest:
    result += this->_RtsWifiIpRequest.Size(); // RtsWifiIpRequest
    break;
  case Tag::RtsWifiIpResponse:
    result += this->_RtsWifiIpResponse.Size(); // RtsWifiIpResponse
    break;
  case Tag::RtsStatusRequest:
    result += this->_RtsStatusRequest.Size(); // RtsStatusRequest
    break;
  case Tag::RtsStatusResponse_5:
    result += this->_RtsStatusResponse_5.Size(); // RtsStatusResponse_5
    break;
  case Tag::RtsWifiScanRequest:
    result += this->_RtsWifiScanRequest.Size(); // RtsWifiScanRequest
    break;
  case Tag::RtsWifiScanResponse_3:
    result += this->_RtsWifiScanResponse_3.Size(); // RtsWifiScanResponse_3
    break;
  case Tag::RtsOtaUpdateRequest:
    result += this->_RtsOtaUpdateRequest.Size(); // RtsOtaUpdateRequest
    break;
  case Tag::RtsOtaUpdateResponse:
    result += this->_RtsOtaUpdateResponse.Size(); // RtsOtaUpdateResponse
    break;
  case Tag::RtsCancelPairing:
    result += this->_RtsCancelPairing.Size(); // RtsCancelPairing
    break;
  case Tag::RtsForceDisconnect:
    result += this->_RtsForceDisconnect.Size(); // RtsForceDisconnect
    break;
  case Tag::RtsAck:
    result += this->_RtsAck.Size(); // RtsAck
    break;
  case Tag::RtsWifiAccessPointRequest:
    result += this->_RtsWifiAccessPointRequest.Size(); // RtsWifiAccessPointRequest
    break;
  case Tag::RtsWifiAccessPointResponse:
    result += this->_RtsWifiAccessPointResponse.Size(); // RtsWifiAccessPointResponse
    break;
  case Tag::RtsSshRequest:
    result += this->_RtsSshRequest.Size(); // RtsSshRequest
    break;
  case Tag::RtsSshResponse:
    result += this->_RtsSshResponse.Size(); // RtsSshResponse
    break;
  case Tag::RtsOtaCancelRequest:
    result += this->_RtsOtaCancelRequest.Size(); // RtsOtaCancelRequest
    break;
  case Tag::RtsLogRequest:
    result += this->_RtsLogRequest.Size(); // RtsLogRequest
    break;
  case Tag::RtsLogResponse:
    result += this->_RtsLogResponse.Size(); // RtsLogResponse
    break;
  case Tag::RtsFileDownload:
    result += this->_RtsFileDownload.Size(); // RtsFileDownload
    break;
  case Tag::RtsWifiForgetRequest:
    result += this->_RtsWifiForgetRequest.Size(); // RtsWifiForgetRequest
    break;
  case Tag::RtsWifiForgetResponse:
    result += this->_RtsWifiForgetResponse.Size(); // RtsWifiForgetResponse
    break;
  case Tag::RtsCloudSessionRequest_2:
    result += this->_RtsCloudSessionRequest_2.Size(); // RtsCloudSessionRequest_2
    break;
  case Tag::RtsCloudSessionResponse:
    result += this->_RtsCloudSessionResponse.Size(); // RtsCloudSessionResponse
    break;
  case Tag::RtsAppConnectionIdRequest:
    result += this->_RtsAppConnectionIdRequest.Size(); // RtsAppConnectionIdRequest
    break;
  case Tag::RtsAppConnectionIdResponse:
    result += this->_RtsAppConnectionIdResponse.Size(); // RtsAppConnectionIdResponse
    break;
  case Tag::RtsResponse:
    result += this->_RtsResponse.Size(); // RtsResponse
    break;
  case Tag::RtsSdkProxyRequest:
    result += this->_RtsSdkProxyRequest.Size(); // RtsSdkProxyRequest
    break;
  case Tag::RtsSdkProxyResponse:
    result += this->_RtsSdkProxyResponse.Size(); // RtsSdkProxyResponse
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection_5::operator==(const RtsConnection_5& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnRequest:
    return this->_RtsConnRequest == other._RtsConnRequest;
  case Tag::RtsConnResponse:
    return this->_RtsConnResponse == other._RtsConnResponse;
  case Tag::RtsNonceMessage:
    return this->_RtsNonceMessage == other._RtsNonceMessage;
  case Tag::RtsChallengeMessage:
    return this->_RtsChallengeMessage == other._RtsChallengeMessage;
  case Tag::RtsChallengeSuccessMessage:
    return this->_RtsChallengeSuccessMessage == other._RtsChallengeSuccessMessage;
  case Tag::RtsWifiConnectRequest:
    return this->_RtsWifiConnectRequest == other._RtsWifiConnectRequest;
  case Tag::RtsWifiConnectResponse_3:
    return this->_RtsWifiConnectResponse_3 == other._RtsWifiConnectResponse_3;
  case Tag::RtsWifiIpRequest:
    return this->_RtsWifiIpRequest == other._RtsWifiIpRequest;
  case Tag::RtsWifiIpResponse:
    return this->_RtsWifiIpResponse == other._RtsWifiIpResponse;
  case Tag::RtsStatusRequest:
    return this->_RtsStatusRequest == other._RtsStatusRequest;
  case Tag::RtsStatusResponse_5:
    return this->_RtsStatusResponse_5 == other._RtsStatusResponse_5;
  case Tag::RtsWifiScanRequest:
    return this->_RtsWifiScanRequest == other._RtsWifiScanRequest;
  case Tag::RtsWifiScanResponse_3:
    return this->_RtsWifiScanResponse_3 == other._RtsWifiScanResponse_3;
  case Tag::RtsOtaUpdateRequest:
    return this->_RtsOtaUpdateRequest == other._RtsOtaUpdateRequest;
  case Tag::RtsOtaUpdateResponse:
    return this->_RtsOtaUpdateResponse == other._RtsOtaUpdateResponse;
  case Tag::RtsCancelPairing:
    return this->_RtsCancelPairing == other._RtsCancelPairing;
  case Tag::RtsForceDisconnect:
    return this->_RtsForceDisconnect == other._RtsForceDisconnect;
  case Tag::RtsAck:
    return this->_RtsAck == other._RtsAck;
  case Tag::RtsWifiAccessPointRequest:
    return this->_RtsWifiAccessPointRequest == other._RtsWifiAccessPointRequest;
  case Tag::RtsWifiAccessPointResponse:
    return this->_RtsWifiAccessPointResponse == other._RtsWifiAccessPointResponse;
  case Tag::RtsSshRequest:
    return this->_RtsSshRequest == other._RtsSshRequest;
  case Tag::RtsSshResponse:
    return this->_RtsSshResponse == other._RtsSshResponse;
  case Tag::RtsOtaCancelRequest:
    return this->_RtsOtaCancelRequest == other._RtsOtaCancelRequest;
  case Tag::RtsLogRequest:
    return this->_RtsLogRequest == other._RtsLogRequest;
  case Tag::RtsLogResponse:
    return this->_RtsLogResponse == other._RtsLogResponse;
  case Tag::RtsFileDownload:
    return this->_RtsFileDownload == other._RtsFileDownload;
  case Tag::RtsWifiForgetRequest:
    return this->_RtsWifiForgetRequest == other._RtsWifiForgetRequest;
  case Tag::RtsWifiForgetResponse:
    return this->_RtsWifiForgetResponse == other._RtsWifiForgetResponse;
  case Tag::RtsCloudSessionRequest_2:
    return this->_RtsCloudSessionRequest_2 == other._RtsCloudSessionRequest_2;
  case Tag::RtsCloudSessionResponse:
    return this->_RtsCloudSessionResponse == other._RtsCloudSessionResponse;
  case Tag::RtsAppConnectionIdRequest:
    return this->_RtsAppConnectionIdRequest == other._RtsAppConnectionIdRequest;
  case Tag::RtsAppConnectionIdResponse:
    return this->_RtsAppConnectionIdResponse == other._RtsAppConnectionIdResponse;
  case Tag::RtsResponse:
    return this->_RtsResponse == other._RtsResponse;
  case Tag::RtsSdkProxyRequest:
    return this->_RtsSdkProxyRequest == other._RtsSdkProxyRequest;
  case Tag::RtsSdkProxyResponse:
    return this->_RtsSdkProxyResponse == other._RtsSdkProxyResponse;
  default:
    return true;
  }
}

bool RtsConnection_5::operator!=(const RtsConnection_5& other) const
{
  return !(operator==(other));
}

void RtsConnection_5::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnRequest:
    _RtsConnRequest.~RtsConnRequest();
    break;
  case Tag::RtsConnResponse:
    _RtsConnResponse.~RtsConnResponse();
    break;
  case Tag::RtsNonceMessage:
    _RtsNonceMessage.~RtsNonceMessage();
    break;
  case Tag::RtsChallengeMessage:
    _RtsChallengeMessage.~RtsChallengeMessage();
    break;
  case Tag::RtsChallengeSuccessMessage:
    _RtsChallengeSuccessMessage.~RtsChallengeSuccessMessage();
    break;
  case Tag::RtsWifiConnectRequest:
    _RtsWifiConnectRequest.~RtsWifiConnectRequest();
    break;
  case Tag::RtsWifiConnectResponse_3:
    _RtsWifiConnectResponse_3.~RtsWifiConnectResponse_3();
    break;
  case Tag::RtsWifiIpRequest:
    _RtsWifiIpRequest.~RtsWifiIpRequest();
    break;
  case Tag::RtsWifiIpResponse:
    _RtsWifiIpResponse.~RtsWifiIpResponse();
    break;
  case Tag::RtsStatusRequest:
    _RtsStatusRequest.~RtsStatusRequest();
    break;
  case Tag::RtsStatusResponse_5:
    _RtsStatusResponse_5.~RtsStatusResponse_5();
    break;
  case Tag::RtsWifiScanRequest:
    _RtsWifiScanRequest.~RtsWifiScanRequest();
    break;
  case Tag::RtsWifiScanResponse_3:
    _RtsWifiScanResponse_3.~RtsWifiScanResponse_3();
    break;
  case Tag::RtsOtaUpdateRequest:
    _RtsOtaUpdateRequest.~RtsOtaUpdateRequest();
    break;
  case Tag::RtsOtaUpdateResponse:
    _RtsOtaUpdateResponse.~RtsOtaUpdateResponse();
    break;
  case Tag::RtsCancelPairing:
    _RtsCancelPairing.~RtsCancelPairing();
    break;
  case Tag::RtsForceDisconnect:
    _RtsForceDisconnect.~RtsForceDisconnect();
    break;
  case Tag::RtsAck:
    _RtsAck.~RtsAck();
    break;
  case Tag::RtsWifiAccessPointRequest:
    _RtsWifiAccessPointRequest.~RtsWifiAccessPointRequest();
    break;
  case Tag::RtsWifiAccessPointResponse:
    _RtsWifiAccessPointResponse.~RtsWifiAccessPointResponse();
    break;
  case Tag::RtsSshRequest:
    _RtsSshRequest.~RtsSshRequest();
    break;
  case Tag::RtsSshResponse:
    _RtsSshResponse.~RtsSshResponse();
    break;
  case Tag::RtsOtaCancelRequest:
    _RtsOtaCancelRequest.~RtsOtaCancelRequest();
    break;
  case Tag::RtsLogRequest:
    _RtsLogRequest.~RtsLogRequest();
    break;
  case Tag::RtsLogResponse:
    _RtsLogResponse.~RtsLogResponse();
    break;
  case Tag::RtsFileDownload:
    _RtsFileDownload.~RtsFileDownload();
    break;
  case Tag::RtsWifiForgetRequest:
    _RtsWifiForgetRequest.~RtsWifiForgetRequest();
    break;
  case Tag::RtsWifiForgetResponse:
    _RtsWifiForgetResponse.~RtsWifiForgetResponse();
    break;
  case Tag::RtsCloudSessionRequest_2:
    _RtsCloudSessionRequest_2.~RtsCloudSessionRequest_2();
    break;
  case Tag::RtsCloudSessionResponse:
    _RtsCloudSessionResponse.~RtsCloudSessionResponse();
    break;
  case Tag::RtsAppConnectionIdRequest:
    _RtsAppConnectionIdRequest.~RtsAppConnectionIdRequest();
    break;
  case Tag::RtsAppConnectionIdResponse:
    _RtsAppConnectionIdResponse.~RtsAppConnectionIdResponse();
    break;
  case Tag::RtsResponse:
    _RtsResponse.~RtsResponse();
    break;
  case Tag::RtsSdkProxyRequest:
    _RtsSdkProxyRequest.~RtsSdkProxyRequest();
    break;
  case Tag::RtsSdkProxyResponse:
    _RtsSdkProxyResponse.~RtsSdkProxyResponse();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnection_5TagToString(const RtsConnection_5Tag tag) {
  switch(tag) {
  case RtsConnection_5Tag::Error:
    return "Error";
  case RtsConnection_5Tag::RtsConnRequest:
    return "RtsConnRequest";
  case RtsConnection_5Tag::RtsConnResponse:
    return "RtsConnResponse";
  case RtsConnection_5Tag::RtsNonceMessage:
    return "RtsNonceMessage";
  case RtsConnection_5Tag::RtsChallengeMessage:
    return "RtsChallengeMessage";
  case RtsConnection_5Tag::RtsChallengeSuccessMessage:
    return "RtsChallengeSuccessMessage";
  case RtsConnection_5Tag::RtsWifiConnectRequest:
    return "RtsWifiConnectRequest";
  case RtsConnection_5Tag::RtsWifiConnectResponse_3:
    return "RtsWifiConnectResponse_3";
  case RtsConnection_5Tag::RtsWifiIpRequest:
    return "RtsWifiIpRequest";
  case RtsConnection_5Tag::RtsWifiIpResponse:
    return "RtsWifiIpResponse";
  case RtsConnection_5Tag::RtsStatusRequest:
    return "RtsStatusRequest";
  case RtsConnection_5Tag::RtsStatusResponse_5:
    return "RtsStatusResponse_5";
  case RtsConnection_5Tag::RtsWifiScanRequest:
    return "RtsWifiScanRequest";
  case RtsConnection_5Tag::RtsWifiScanResponse_3:
    return "RtsWifiScanResponse_3";
  case RtsConnection_5Tag::RtsOtaUpdateRequest:
    return "RtsOtaUpdateRequest";
  case RtsConnection_5Tag::RtsOtaUpdateResponse:
    return "RtsOtaUpdateResponse";
  case RtsConnection_5Tag::RtsCancelPairing:
    return "RtsCancelPairing";
  case RtsConnection_5Tag::RtsForceDisconnect:
    return "RtsForceDisconnect";
  case RtsConnection_5Tag::RtsAck:
    return "RtsAck";
  case RtsConnection_5Tag::RtsWifiAccessPointRequest:
    return "RtsWifiAccessPointRequest";
  case RtsConnection_5Tag::RtsWifiAccessPointResponse:
    return "RtsWifiAccessPointResponse";
  case RtsConnection_5Tag::RtsSshRequest:
    return "RtsSshRequest";
  case RtsConnection_5Tag::RtsSshResponse:
    return "RtsSshResponse";
  case RtsConnection_5Tag::RtsOtaCancelRequest:
    return "RtsOtaCancelRequest";
  case RtsConnection_5Tag::RtsLogRequest:
    return "RtsLogRequest";
  case RtsConnection_5Tag::RtsLogResponse:
    return "RtsLogResponse";
  case RtsConnection_5Tag::RtsFileDownload:
    return "RtsFileDownload";
  case RtsConnection_5Tag::RtsWifiForgetRequest:
    return "RtsWifiForgetRequest";
  case RtsConnection_5Tag::RtsWifiForgetResponse:
    return "RtsWifiForgetResponse";
  case RtsConnection_5Tag::RtsCloudSessionRequest_2:
    return "RtsCloudSessionRequest_2";
  case RtsConnection_5Tag::RtsCloudSessionResponse:
    return "RtsCloudSessionResponse";
  case RtsConnection_5Tag::RtsAppConnectionIdRequest:
    return "RtsAppConnectionIdRequest";
  case RtsConnection_5Tag::RtsAppConnectionIdResponse:
    return "RtsAppConnectionIdResponse";
  case RtsConnection_5Tag::RtsResponse:
    return "RtsResponse";
  case RtsConnection_5Tag::RtsSdkProxyRequest:
    return "RtsSdkProxyRequest";
  case RtsConnection_5Tag::RtsSdkProxyResponse:
    return "RtsSdkProxyResponse";
  default:
    return "INVALID";
  }
}

const char* RtsConnection_5VersionHashStr = "4618409280669547ce2a1e664f8ae2fe";

const uint8_t RtsConnection_5VersionHash[16] = { 
    0x46, 0x18, 0x40, 0x92, 0x80, 0x66, 0x95, 0x47, 0xce, 0x2a, 0x1e, 0x66, 0x4f, 0x8a, 0xe2, 0xfe 
};

// UNION RtsConnection_1

RtsConnection_1::RtsConnection_1(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection_1::RtsConnection_1(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection_1::RtsConnection_1(const RtsConnection_1& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(other._RtsWifiConnectResponse);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse:
    new(&(this->_RtsStatusResponse)) Anki::Vector::ExternalComms::RtsStatusResponse(other._RtsStatusResponse);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse:
    new(&(this->_RtsWifiScanResponse)) Anki::Vector::ExternalComms::RtsWifiScanResponse(other._RtsWifiScanResponse);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection_1::RtsConnection_1(RtsConnection_1&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(other._RtsWifiConnectResponse));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse:
    new(&(this->_RtsStatusResponse)) Anki::Vector::ExternalComms::RtsStatusResponse(std::move(other._RtsStatusResponse));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse:
    new(&(this->_RtsWifiScanResponse)) Anki::Vector::ExternalComms::RtsWifiScanResponse(std::move(other._RtsWifiScanResponse));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection_1& RtsConnection_1::operator=(const RtsConnection_1& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(other._RtsConnRequest);
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(other._RtsConnResponse);
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(other._RtsNonceMessage);
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(other._RtsChallengeMessage);
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(other._RtsChallengeSuccessMessage);
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(other._RtsWifiConnectRequest);
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(other._RtsWifiConnectResponse);
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(other._RtsWifiIpRequest);
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(other._RtsWifiIpResponse);
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(other._RtsStatusRequest);
    break;
  case Tag::RtsStatusResponse:
    new(&(this->_RtsStatusResponse)) Anki::Vector::ExternalComms::RtsStatusResponse(other._RtsStatusResponse);
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(other._RtsWifiScanRequest);
    break;
  case Tag::RtsWifiScanResponse:
    new(&(this->_RtsWifiScanResponse)) Anki::Vector::ExternalComms::RtsWifiScanResponse(other._RtsWifiScanResponse);
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(other._RtsOtaUpdateRequest);
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(other._RtsOtaUpdateResponse);
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(other._RtsCancelPairing);
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(other._RtsForceDisconnect);
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(other._RtsAck);
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(other._RtsWifiAccessPointRequest);
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(other._RtsWifiAccessPointResponse);
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(other._RtsSshRequest);
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(other._RtsSshResponse);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection_1& RtsConnection_1::operator=(RtsConnection_1&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnRequest:
    new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(std::move(other._RtsConnRequest));
    break;
  case Tag::RtsConnResponse:
    new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(std::move(other._RtsConnResponse));
    break;
  case Tag::RtsNonceMessage:
    new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(other._RtsNonceMessage));
    break;
  case Tag::RtsChallengeMessage:
    new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(other._RtsChallengeMessage));
    break;
  case Tag::RtsChallengeSuccessMessage:
    new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(other._RtsChallengeSuccessMessage));
    break;
  case Tag::RtsWifiConnectRequest:
    new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(other._RtsWifiConnectRequest));
    break;
  case Tag::RtsWifiConnectResponse:
    new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(other._RtsWifiConnectResponse));
    break;
  case Tag::RtsWifiIpRequest:
    new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(other._RtsWifiIpRequest));
    break;
  case Tag::RtsWifiIpResponse:
    new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(other._RtsWifiIpResponse));
    break;
  case Tag::RtsStatusRequest:
    new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(other._RtsStatusRequest));
    break;
  case Tag::RtsStatusResponse:
    new(&(this->_RtsStatusResponse)) Anki::Vector::ExternalComms::RtsStatusResponse(std::move(other._RtsStatusResponse));
    break;
  case Tag::RtsWifiScanRequest:
    new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(other._RtsWifiScanRequest));
    break;
  case Tag::RtsWifiScanResponse:
    new(&(this->_RtsWifiScanResponse)) Anki::Vector::ExternalComms::RtsWifiScanResponse(std::move(other._RtsWifiScanResponse));
    break;
  case Tag::RtsOtaUpdateRequest:
    new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(other._RtsOtaUpdateRequest));
    break;
  case Tag::RtsOtaUpdateResponse:
    new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(other._RtsOtaUpdateResponse));
    break;
  case Tag::RtsCancelPairing:
    new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(other._RtsCancelPairing));
    break;
  case Tag::RtsForceDisconnect:
    new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(other._RtsForceDisconnect));
    break;
  case Tag::RtsAck:
    new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(std::move(other._RtsAck));
    break;
  case Tag::RtsWifiAccessPointRequest:
    new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(other._RtsWifiAccessPointRequest));
    break;
  case Tag::RtsWifiAccessPointResponse:
    new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(other._RtsWifiAccessPointResponse));
    break;
  case Tag::RtsSshRequest:
    new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(std::move(other._RtsSshRequest));
    break;
  case Tag::RtsSshResponse:
    new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(std::move(other._RtsSshResponse));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection_1 RtsConnection_1::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection_1 m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection_1::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection_1::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection_1::Get_<RtsConnection_1::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection_1::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  RtsConnection_1 m;
  m.Set_RtsConnRequest(new_RtsConnRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
  _tag = Tag::RtsConnRequest;
}

const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_1::Get_RtsConnRequest() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

void RtsConnection_1::Set_RtsConnRequest(const Anki::Vector::ExternalComms::RtsConnRequest& new_RtsConnRequest)
{
  if(this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = new_RtsConnRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(new_RtsConnRequest);
    _tag = Tag::RtsConnRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsConnRequest>() const
{
  assert(_tag == Tag::RtsConnRequest);
  return this->_RtsConnRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsConnRequest>(Anki::Vector::ExternalComms::RtsConnRequest member)
{
  return CreateRtsConnRequest(std::move(member));
}

void RtsConnection_1::Set_RtsConnRequest(Anki::Vector::ExternalComms::RtsConnRequest&& new_RtsConnRequest)
{
  if (this->_tag == Tag::RtsConnRequest) {
    this->_RtsConnRequest = std::move(new_RtsConnRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnRequest) Anki::Vector::ExternalComms::RtsConnRequest(std::move(new_RtsConnRequest));
    _tag = Tag::RtsConnRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  RtsConnection_1 m;
  m.Set_RtsConnResponse(new_RtsConnResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
  _tag = Tag::RtsConnResponse;
}

const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_1::Get_RtsConnResponse() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

void RtsConnection_1::Set_RtsConnResponse(const Anki::Vector::ExternalComms::RtsConnResponse& new_RtsConnResponse)
{
  if(this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = new_RtsConnResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(new_RtsConnResponse);
    _tag = Tag::RtsConnResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsConnResponse>() const
{
  assert(_tag == Tag::RtsConnResponse);
  return this->_RtsConnResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsConnResponse>(Anki::Vector::ExternalComms::RtsConnResponse member)
{
  return CreateRtsConnResponse(std::move(member));
}

void RtsConnection_1::Set_RtsConnResponse(Anki::Vector::ExternalComms::RtsConnResponse&& new_RtsConnResponse)
{
  if (this->_tag == Tag::RtsConnResponse) {
    this->_RtsConnResponse = std::move(new_RtsConnResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnResponse) Anki::Vector::ExternalComms::RtsConnResponse(std::move(new_RtsConnResponse));
    _tag = Tag::RtsConnResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  RtsConnection_1 m;
  m.Set_RtsNonceMessage(new_RtsNonceMessage);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
  _tag = Tag::RtsNonceMessage;
}

const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_1::Get_RtsNonceMessage() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

void RtsConnection_1::Set_RtsNonceMessage(const Anki::Vector::ExternalComms::RtsNonceMessage& new_RtsNonceMessage)
{
  if(this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = new_RtsNonceMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(new_RtsNonceMessage);
    _tag = Tag::RtsNonceMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsNonceMessage& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsNonceMessage>() const
{
  assert(_tag == Tag::RtsNonceMessage);
  return this->_RtsNonceMessage;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsNonceMessage>(Anki::Vector::ExternalComms::RtsNonceMessage member)
{
  return CreateRtsNonceMessage(std::move(member));
}

void RtsConnection_1::Set_RtsNonceMessage(Anki::Vector::ExternalComms::RtsNonceMessage&& new_RtsNonceMessage)
{
  if (this->_tag == Tag::RtsNonceMessage) {
    this->_RtsNonceMessage = std::move(new_RtsNonceMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsNonceMessage) Anki::Vector::ExternalComms::RtsNonceMessage(std::move(new_RtsNonceMessage));
    _tag = Tag::RtsNonceMessage;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  RtsConnection_1 m;
  m.Set_RtsChallengeMessage(new_RtsChallengeMessage);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
  _tag = Tag::RtsChallengeMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_1::Get_RtsChallengeMessage() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

void RtsConnection_1::Set_RtsChallengeMessage(const Anki::Vector::ExternalComms::RtsChallengeMessage& new_RtsChallengeMessage)
{
  if(this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = new_RtsChallengeMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(new_RtsChallengeMessage);
    _tag = Tag::RtsChallengeMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeMessage& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsChallengeMessage>() const
{
  assert(_tag == Tag::RtsChallengeMessage);
  return this->_RtsChallengeMessage;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsChallengeMessage>(Anki::Vector::ExternalComms::RtsChallengeMessage member)
{
  return CreateRtsChallengeMessage(std::move(member));
}

void RtsConnection_1::Set_RtsChallengeMessage(Anki::Vector::ExternalComms::RtsChallengeMessage&& new_RtsChallengeMessage)
{
  if (this->_tag == Tag::RtsChallengeMessage) {
    this->_RtsChallengeMessage = std::move(new_RtsChallengeMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeMessage) Anki::Vector::ExternalComms::RtsChallengeMessage(std::move(new_RtsChallengeMessage));
    _tag = Tag::RtsChallengeMessage;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  RtsConnection_1 m;
  m.Set_RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
  _tag = Tag::RtsChallengeSuccessMessage;
}

const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_1::Get_RtsChallengeSuccessMessage() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

void RtsConnection_1::Set_RtsChallengeSuccessMessage(const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& new_RtsChallengeSuccessMessage)
{
  if(this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = new_RtsChallengeSuccessMessage;
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(new_RtsChallengeSuccessMessage);
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsChallengeSuccessMessage& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsChallengeSuccessMessage>() const
{
  assert(_tag == Tag::RtsChallengeSuccessMessage);
  return this->_RtsChallengeSuccessMessage;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsChallengeSuccessMessage>(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage member)
{
  return CreateRtsChallengeSuccessMessage(std::move(member));
}

void RtsConnection_1::Set_RtsChallengeSuccessMessage(Anki::Vector::ExternalComms::RtsChallengeSuccessMessage&& new_RtsChallengeSuccessMessage)
{
  if (this->_tag == Tag::RtsChallengeSuccessMessage) {
    this->_RtsChallengeSuccessMessage = std::move(new_RtsChallengeSuccessMessage);
  }
  else {
    ClearCurrent();
    new(&this->_RtsChallengeSuccessMessage) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(std::move(new_RtsChallengeSuccessMessage));
    _tag = Tag::RtsChallengeSuccessMessage;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  RtsConnection_1 m;
  m.Set_RtsWifiConnectRequest(new_RtsWifiConnectRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
  _tag = Tag::RtsWifiConnectRequest;
}

const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_1::Get_RtsWifiConnectRequest() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

void RtsConnection_1::Set_RtsWifiConnectRequest(const Anki::Vector::ExternalComms::RtsWifiConnectRequest& new_RtsWifiConnectRequest)
{
  if(this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = new_RtsWifiConnectRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(new_RtsWifiConnectRequest);
    _tag = Tag::RtsWifiConnectRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiConnectRequest>() const
{
  assert(_tag == Tag::RtsWifiConnectRequest);
  return this->_RtsWifiConnectRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiConnectRequest>(Anki::Vector::ExternalComms::RtsWifiConnectRequest member)
{
  return CreateRtsWifiConnectRequest(std::move(member));
}

void RtsConnection_1::Set_RtsWifiConnectRequest(Anki::Vector::ExternalComms::RtsWifiConnectRequest&& new_RtsWifiConnectRequest)
{
  if (this->_tag == Tag::RtsWifiConnectRequest) {
    this->_RtsWifiConnectRequest = std::move(new_RtsWifiConnectRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectRequest) Anki::Vector::ExternalComms::RtsWifiConnectRequest(std::move(new_RtsWifiConnectRequest));
    _tag = Tag::RtsWifiConnectRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiConnectResponse(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  RtsConnection_1 m;
  m.Set_RtsWifiConnectResponse(new_RtsWifiConnectResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(new_RtsWifiConnectResponse));
  _tag = Tag::RtsWifiConnectResponse;
}

const Anki::Vector::ExternalComms::RtsWifiConnectResponse& RtsConnection_1::Get_RtsWifiConnectResponse() const
{
  assert(_tag == Tag::RtsWifiConnectResponse);
  return this->_RtsWifiConnectResponse;
}

void RtsConnection_1::Set_RtsWifiConnectResponse(const Anki::Vector::ExternalComms::RtsWifiConnectResponse& new_RtsWifiConnectResponse)
{
  if(this->_tag == Tag::RtsWifiConnectResponse) {
    this->_RtsWifiConnectResponse = new_RtsWifiConnectResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(new_RtsWifiConnectResponse);
    _tag = Tag::RtsWifiConnectResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiConnectResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiConnectResponse>() const
{
  assert(_tag == Tag::RtsWifiConnectResponse);
  return this->_RtsWifiConnectResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiConnectResponse>(Anki::Vector::ExternalComms::RtsWifiConnectResponse member)
{
  return CreateRtsWifiConnectResponse(std::move(member));
}

void RtsConnection_1::Set_RtsWifiConnectResponse(Anki::Vector::ExternalComms::RtsWifiConnectResponse&& new_RtsWifiConnectResponse)
{
  if (this->_tag == Tag::RtsWifiConnectResponse) {
    this->_RtsWifiConnectResponse = std::move(new_RtsWifiConnectResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiConnectResponse) Anki::Vector::ExternalComms::RtsWifiConnectResponse(std::move(new_RtsWifiConnectResponse));
    _tag = Tag::RtsWifiConnectResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  RtsConnection_1 m;
  m.Set_RtsWifiIpRequest(new_RtsWifiIpRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
  _tag = Tag::RtsWifiIpRequest;
}

const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_1::Get_RtsWifiIpRequest() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

void RtsConnection_1::Set_RtsWifiIpRequest(const Anki::Vector::ExternalComms::RtsWifiIpRequest& new_RtsWifiIpRequest)
{
  if(this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = new_RtsWifiIpRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(new_RtsWifiIpRequest);
    _tag = Tag::RtsWifiIpRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiIpRequest>() const
{
  assert(_tag == Tag::RtsWifiIpRequest);
  return this->_RtsWifiIpRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiIpRequest>(Anki::Vector::ExternalComms::RtsWifiIpRequest member)
{
  return CreateRtsWifiIpRequest(std::move(member));
}

void RtsConnection_1::Set_RtsWifiIpRequest(Anki::Vector::ExternalComms::RtsWifiIpRequest&& new_RtsWifiIpRequest)
{
  if (this->_tag == Tag::RtsWifiIpRequest) {
    this->_RtsWifiIpRequest = std::move(new_RtsWifiIpRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpRequest) Anki::Vector::ExternalComms::RtsWifiIpRequest(std::move(new_RtsWifiIpRequest));
    _tag = Tag::RtsWifiIpRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  RtsConnection_1 m;
  m.Set_RtsWifiIpResponse(new_RtsWifiIpResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
  _tag = Tag::RtsWifiIpResponse;
}

const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_1::Get_RtsWifiIpResponse() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

void RtsConnection_1::Set_RtsWifiIpResponse(const Anki::Vector::ExternalComms::RtsWifiIpResponse& new_RtsWifiIpResponse)
{
  if(this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = new_RtsWifiIpResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(new_RtsWifiIpResponse);
    _tag = Tag::RtsWifiIpResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiIpResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiIpResponse>() const
{
  assert(_tag == Tag::RtsWifiIpResponse);
  return this->_RtsWifiIpResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiIpResponse>(Anki::Vector::ExternalComms::RtsWifiIpResponse member)
{
  return CreateRtsWifiIpResponse(std::move(member));
}

void RtsConnection_1::Set_RtsWifiIpResponse(Anki::Vector::ExternalComms::RtsWifiIpResponse&& new_RtsWifiIpResponse)
{
  if (this->_tag == Tag::RtsWifiIpResponse) {
    this->_RtsWifiIpResponse = std::move(new_RtsWifiIpResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiIpResponse) Anki::Vector::ExternalComms::RtsWifiIpResponse(std::move(new_RtsWifiIpResponse));
    _tag = Tag::RtsWifiIpResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  RtsConnection_1 m;
  m.Set_RtsStatusRequest(new_RtsStatusRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
  _tag = Tag::RtsStatusRequest;
}

const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_1::Get_RtsStatusRequest() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

void RtsConnection_1::Set_RtsStatusRequest(const Anki::Vector::ExternalComms::RtsStatusRequest& new_RtsStatusRequest)
{
  if(this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = new_RtsStatusRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(new_RtsStatusRequest);
    _tag = Tag::RtsStatusRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsStatusRequest>() const
{
  assert(_tag == Tag::RtsStatusRequest);
  return this->_RtsStatusRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsStatusRequest>(Anki::Vector::ExternalComms::RtsStatusRequest member)
{
  return CreateRtsStatusRequest(std::move(member));
}

void RtsConnection_1::Set_RtsStatusRequest(Anki::Vector::ExternalComms::RtsStatusRequest&& new_RtsStatusRequest)
{
  if (this->_tag == Tag::RtsStatusRequest) {
    this->_RtsStatusRequest = std::move(new_RtsStatusRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusRequest) Anki::Vector::ExternalComms::RtsStatusRequest(std::move(new_RtsStatusRequest));
    _tag = Tag::RtsStatusRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsStatusResponse(Anki::Vector::ExternalComms::RtsStatusResponse&& new_RtsStatusResponse)
{
  RtsConnection_1 m;
  m.Set_RtsStatusResponse(new_RtsStatusResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsStatusResponse&& new_RtsStatusResponse)
{
  new(&this->_RtsStatusResponse) Anki::Vector::ExternalComms::RtsStatusResponse(std::move(new_RtsStatusResponse));
  _tag = Tag::RtsStatusResponse;
}

const Anki::Vector::ExternalComms::RtsStatusResponse& RtsConnection_1::Get_RtsStatusResponse() const
{
  assert(_tag == Tag::RtsStatusResponse);
  return this->_RtsStatusResponse;
}

void RtsConnection_1::Set_RtsStatusResponse(const Anki::Vector::ExternalComms::RtsStatusResponse& new_RtsStatusResponse)
{
  if(this->_tag == Tag::RtsStatusResponse) {
    this->_RtsStatusResponse = new_RtsStatusResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse) Anki::Vector::ExternalComms::RtsStatusResponse(new_RtsStatusResponse);
    _tag = Tag::RtsStatusResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsStatusResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsStatusResponse>() const
{
  assert(_tag == Tag::RtsStatusResponse);
  return this->_RtsStatusResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsStatusResponse>(Anki::Vector::ExternalComms::RtsStatusResponse member)
{
  return CreateRtsStatusResponse(std::move(member));
}

void RtsConnection_1::Set_RtsStatusResponse(Anki::Vector::ExternalComms::RtsStatusResponse&& new_RtsStatusResponse)
{
  if (this->_tag == Tag::RtsStatusResponse) {
    this->_RtsStatusResponse = std::move(new_RtsStatusResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsStatusResponse) Anki::Vector::ExternalComms::RtsStatusResponse(std::move(new_RtsStatusResponse));
    _tag = Tag::RtsStatusResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  RtsConnection_1 m;
  m.Set_RtsWifiScanRequest(new_RtsWifiScanRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
  _tag = Tag::RtsWifiScanRequest;
}

const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_1::Get_RtsWifiScanRequest() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

void RtsConnection_1::Set_RtsWifiScanRequest(const Anki::Vector::ExternalComms::RtsWifiScanRequest& new_RtsWifiScanRequest)
{
  if(this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = new_RtsWifiScanRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(new_RtsWifiScanRequest);
    _tag = Tag::RtsWifiScanRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiScanRequest>() const
{
  assert(_tag == Tag::RtsWifiScanRequest);
  return this->_RtsWifiScanRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiScanRequest>(Anki::Vector::ExternalComms::RtsWifiScanRequest member)
{
  return CreateRtsWifiScanRequest(std::move(member));
}

void RtsConnection_1::Set_RtsWifiScanRequest(Anki::Vector::ExternalComms::RtsWifiScanRequest&& new_RtsWifiScanRequest)
{
  if (this->_tag == Tag::RtsWifiScanRequest) {
    this->_RtsWifiScanRequest = std::move(new_RtsWifiScanRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanRequest) Anki::Vector::ExternalComms::RtsWifiScanRequest(std::move(new_RtsWifiScanRequest));
    _tag = Tag::RtsWifiScanRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiScanResponse(Anki::Vector::ExternalComms::RtsWifiScanResponse&& new_RtsWifiScanResponse)
{
  RtsConnection_1 m;
  m.Set_RtsWifiScanResponse(new_RtsWifiScanResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiScanResponse&& new_RtsWifiScanResponse)
{
  new(&this->_RtsWifiScanResponse) Anki::Vector::ExternalComms::RtsWifiScanResponse(std::move(new_RtsWifiScanResponse));
  _tag = Tag::RtsWifiScanResponse;
}

const Anki::Vector::ExternalComms::RtsWifiScanResponse& RtsConnection_1::Get_RtsWifiScanResponse() const
{
  assert(_tag == Tag::RtsWifiScanResponse);
  return this->_RtsWifiScanResponse;
}

void RtsConnection_1::Set_RtsWifiScanResponse(const Anki::Vector::ExternalComms::RtsWifiScanResponse& new_RtsWifiScanResponse)
{
  if(this->_tag == Tag::RtsWifiScanResponse) {
    this->_RtsWifiScanResponse = new_RtsWifiScanResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse) Anki::Vector::ExternalComms::RtsWifiScanResponse(new_RtsWifiScanResponse);
    _tag = Tag::RtsWifiScanResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiScanResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiScanResponse>() const
{
  assert(_tag == Tag::RtsWifiScanResponse);
  return this->_RtsWifiScanResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiScanResponse>(Anki::Vector::ExternalComms::RtsWifiScanResponse member)
{
  return CreateRtsWifiScanResponse(std::move(member));
}

void RtsConnection_1::Set_RtsWifiScanResponse(Anki::Vector::ExternalComms::RtsWifiScanResponse&& new_RtsWifiScanResponse)
{
  if (this->_tag == Tag::RtsWifiScanResponse) {
    this->_RtsWifiScanResponse = std::move(new_RtsWifiScanResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiScanResponse) Anki::Vector::ExternalComms::RtsWifiScanResponse(std::move(new_RtsWifiScanResponse));
    _tag = Tag::RtsWifiScanResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  RtsConnection_1 m;
  m.Set_RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
  _tag = Tag::RtsOtaUpdateRequest;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_1::Get_RtsOtaUpdateRequest() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

void RtsConnection_1::Set_RtsOtaUpdateRequest(const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& new_RtsOtaUpdateRequest)
{
  if(this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = new_RtsOtaUpdateRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(new_RtsOtaUpdateRequest);
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsOtaUpdateRequest>() const
{
  assert(_tag == Tag::RtsOtaUpdateRequest);
  return this->_RtsOtaUpdateRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsOtaUpdateRequest>(Anki::Vector::ExternalComms::RtsOtaUpdateRequest member)
{
  return CreateRtsOtaUpdateRequest(std::move(member));
}

void RtsConnection_1::Set_RtsOtaUpdateRequest(Anki::Vector::ExternalComms::RtsOtaUpdateRequest&& new_RtsOtaUpdateRequest)
{
  if (this->_tag == Tag::RtsOtaUpdateRequest) {
    this->_RtsOtaUpdateRequest = std::move(new_RtsOtaUpdateRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateRequest) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(std::move(new_RtsOtaUpdateRequest));
    _tag = Tag::RtsOtaUpdateRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  RtsConnection_1 m;
  m.Set_RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
  _tag = Tag::RtsOtaUpdateResponse;
}

const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_1::Get_RtsOtaUpdateResponse() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

void RtsConnection_1::Set_RtsOtaUpdateResponse(const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& new_RtsOtaUpdateResponse)
{
  if(this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = new_RtsOtaUpdateResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(new_RtsOtaUpdateResponse);
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsOtaUpdateResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsOtaUpdateResponse>() const
{
  assert(_tag == Tag::RtsOtaUpdateResponse);
  return this->_RtsOtaUpdateResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsOtaUpdateResponse>(Anki::Vector::ExternalComms::RtsOtaUpdateResponse member)
{
  return CreateRtsOtaUpdateResponse(std::move(member));
}

void RtsConnection_1::Set_RtsOtaUpdateResponse(Anki::Vector::ExternalComms::RtsOtaUpdateResponse&& new_RtsOtaUpdateResponse)
{
  if (this->_tag == Tag::RtsOtaUpdateResponse) {
    this->_RtsOtaUpdateResponse = std::move(new_RtsOtaUpdateResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsOtaUpdateResponse) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(std::move(new_RtsOtaUpdateResponse));
    _tag = Tag::RtsOtaUpdateResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  RtsConnection_1 m;
  m.Set_RtsCancelPairing(new_RtsCancelPairing);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
  _tag = Tag::RtsCancelPairing;
}

const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_1::Get_RtsCancelPairing() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

void RtsConnection_1::Set_RtsCancelPairing(const Anki::Vector::ExternalComms::RtsCancelPairing& new_RtsCancelPairing)
{
  if(this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = new_RtsCancelPairing;
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(new_RtsCancelPairing);
    _tag = Tag::RtsCancelPairing;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsCancelPairing& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsCancelPairing>() const
{
  assert(_tag == Tag::RtsCancelPairing);
  return this->_RtsCancelPairing;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsCancelPairing>(Anki::Vector::ExternalComms::RtsCancelPairing member)
{
  return CreateRtsCancelPairing(std::move(member));
}

void RtsConnection_1::Set_RtsCancelPairing(Anki::Vector::ExternalComms::RtsCancelPairing&& new_RtsCancelPairing)
{
  if (this->_tag == Tag::RtsCancelPairing) {
    this->_RtsCancelPairing = std::move(new_RtsCancelPairing);
  }
  else {
    ClearCurrent();
    new(&this->_RtsCancelPairing) Anki::Vector::ExternalComms::RtsCancelPairing(std::move(new_RtsCancelPairing));
    _tag = Tag::RtsCancelPairing;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  RtsConnection_1 m;
  m.Set_RtsForceDisconnect(new_RtsForceDisconnect);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
  _tag = Tag::RtsForceDisconnect;
}

const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_1::Get_RtsForceDisconnect() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

void RtsConnection_1::Set_RtsForceDisconnect(const Anki::Vector::ExternalComms::RtsForceDisconnect& new_RtsForceDisconnect)
{
  if(this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = new_RtsForceDisconnect;
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(new_RtsForceDisconnect);
    _tag = Tag::RtsForceDisconnect;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsForceDisconnect& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsForceDisconnect>() const
{
  assert(_tag == Tag::RtsForceDisconnect);
  return this->_RtsForceDisconnect;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsForceDisconnect>(Anki::Vector::ExternalComms::RtsForceDisconnect member)
{
  return CreateRtsForceDisconnect(std::move(member));
}

void RtsConnection_1::Set_RtsForceDisconnect(Anki::Vector::ExternalComms::RtsForceDisconnect&& new_RtsForceDisconnect)
{
  if (this->_tag == Tag::RtsForceDisconnect) {
    this->_RtsForceDisconnect = std::move(new_RtsForceDisconnect);
  }
  else {
    ClearCurrent();
    new(&this->_RtsForceDisconnect) Anki::Vector::ExternalComms::RtsForceDisconnect(std::move(new_RtsForceDisconnect));
    _tag = Tag::RtsForceDisconnect;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  RtsConnection_1 m;
  m.Set_RtsAck(new_RtsAck);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
  _tag = Tag::RtsAck;
}

const Anki::Vector::ExternalComms::RtsAck& RtsConnection_1::Get_RtsAck() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

void RtsConnection_1::Set_RtsAck(const Anki::Vector::ExternalComms::RtsAck& new_RtsAck)
{
  if(this->_tag == Tag::RtsAck) {
    this->_RtsAck = new_RtsAck;
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(new_RtsAck);
    _tag = Tag::RtsAck;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsAck& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsAck>() const
{
  assert(_tag == Tag::RtsAck);
  return this->_RtsAck;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsAck>(Anki::Vector::ExternalComms::RtsAck member)
{
  return CreateRtsAck(std::move(member));
}

void RtsConnection_1::Set_RtsAck(Anki::Vector::ExternalComms::RtsAck&& new_RtsAck)
{
  if (this->_tag == Tag::RtsAck) {
    this->_RtsAck = std::move(new_RtsAck);
  }
  else {
    ClearCurrent();
    new(&this->_RtsAck) Anki::Vector::ExternalComms::RtsAck(std::move(new_RtsAck));
    _tag = Tag::RtsAck;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  RtsConnection_1 m;
  m.Set_RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
  _tag = Tag::RtsWifiAccessPointRequest;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_1::Get_RtsWifiAccessPointRequest() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

void RtsConnection_1::Set_RtsWifiAccessPointRequest(const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& new_RtsWifiAccessPointRequest)
{
  if(this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = new_RtsWifiAccessPointRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(new_RtsWifiAccessPointRequest);
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiAccessPointRequest>() const
{
  assert(_tag == Tag::RtsWifiAccessPointRequest);
  return this->_RtsWifiAccessPointRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiAccessPointRequest>(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest member)
{
  return CreateRtsWifiAccessPointRequest(std::move(member));
}

void RtsConnection_1::Set_RtsWifiAccessPointRequest(Anki::Vector::ExternalComms::RtsWifiAccessPointRequest&& new_RtsWifiAccessPointRequest)
{
  if (this->_tag == Tag::RtsWifiAccessPointRequest) {
    this->_RtsWifiAccessPointRequest = std::move(new_RtsWifiAccessPointRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointRequest) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(std::move(new_RtsWifiAccessPointRequest));
    _tag = Tag::RtsWifiAccessPointRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  RtsConnection_1 m;
  m.Set_RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
  _tag = Tag::RtsWifiAccessPointResponse;
}

const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_1::Get_RtsWifiAccessPointResponse() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

void RtsConnection_1::Set_RtsWifiAccessPointResponse(const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& new_RtsWifiAccessPointResponse)
{
  if(this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = new_RtsWifiAccessPointResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(new_RtsWifiAccessPointResponse);
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsWifiAccessPointResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsWifiAccessPointResponse>() const
{
  assert(_tag == Tag::RtsWifiAccessPointResponse);
  return this->_RtsWifiAccessPointResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsWifiAccessPointResponse>(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse member)
{
  return CreateRtsWifiAccessPointResponse(std::move(member));
}

void RtsConnection_1::Set_RtsWifiAccessPointResponse(Anki::Vector::ExternalComms::RtsWifiAccessPointResponse&& new_RtsWifiAccessPointResponse)
{
  if (this->_tag == Tag::RtsWifiAccessPointResponse) {
    this->_RtsWifiAccessPointResponse = std::move(new_RtsWifiAccessPointResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsWifiAccessPointResponse) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(std::move(new_RtsWifiAccessPointResponse));
    _tag = Tag::RtsWifiAccessPointResponse;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  RtsConnection_1 m;
  m.Set_RtsSshRequest(new_RtsSshRequest);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
  _tag = Tag::RtsSshRequest;
}

const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_1::Get_RtsSshRequest() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

void RtsConnection_1::Set_RtsSshRequest(const Anki::Vector::ExternalComms::RtsSshRequest& new_RtsSshRequest)
{
  if(this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = new_RtsSshRequest;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(new_RtsSshRequest);
    _tag = Tag::RtsSshRequest;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshRequest& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsSshRequest>() const
{
  assert(_tag == Tag::RtsSshRequest);
  return this->_RtsSshRequest;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsSshRequest>(Anki::Vector::ExternalComms::RtsSshRequest member)
{
  return CreateRtsSshRequest(std::move(member));
}

void RtsConnection_1::Set_RtsSshRequest(Anki::Vector::ExternalComms::RtsSshRequest&& new_RtsSshRequest)
{
  if (this->_tag == Tag::RtsSshRequest) {
    this->_RtsSshRequest = std::move(new_RtsSshRequest);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshRequest) Anki::Vector::ExternalComms::RtsSshRequest(std::move(new_RtsSshRequest));
    _tag = Tag::RtsSshRequest;
  }
}

RtsConnection_1 RtsConnection_1::CreateRtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  RtsConnection_1 m;
  m.Set_RtsSshResponse(new_RtsSshResponse);
  return m;
}

RtsConnection_1::RtsConnection_1(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
  _tag = Tag::RtsSshResponse;
}

const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_1::Get_RtsSshResponse() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

void RtsConnection_1::Set_RtsSshResponse(const Anki::Vector::ExternalComms::RtsSshResponse& new_RtsSshResponse)
{
  if(this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = new_RtsSshResponse;
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(new_RtsSshResponse);
    _tag = Tag::RtsSshResponse;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsSshResponse& RtsConnection_1::Get_<RtsConnection_1::Tag::RtsSshResponse>() const
{
  assert(_tag == Tag::RtsSshResponse);
  return this->_RtsSshResponse;
}

template<>
RtsConnection_1 RtsConnection_1::Create_<RtsConnection_1::Tag::RtsSshResponse>(Anki::Vector::ExternalComms::RtsSshResponse member)
{
  return CreateRtsSshResponse(std::move(member));
}

void RtsConnection_1::Set_RtsSshResponse(Anki::Vector::ExternalComms::RtsSshResponse&& new_RtsSshResponse)
{
  if (this->_tag == Tag::RtsSshResponse) {
    this->_RtsSshResponse = std::move(new_RtsSshResponse);
  }
  else {
    ClearCurrent();
    new(&this->_RtsSshResponse) Anki::Vector::ExternalComms::RtsSshResponse(std::move(new_RtsSshResponse));
    _tag = Tag::RtsSshResponse;
  }
}

size_t RtsConnection_1::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection_1::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsConnRequest)) Anki::Vector::ExternalComms::RtsConnRequest(buffer);
    }
    else {
      this->_RtsConnRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsConnResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsConnResponse)) Anki::Vector::ExternalComms::RtsConnResponse(buffer);
    }
    else {
      this->_RtsConnResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsNonceMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsNonceMessage)) Anki::Vector::ExternalComms::RtsNonceMessage(buffer);
    }
    else {
      this->_RtsNonceMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeMessage)) Anki::Vector::ExternalComms::RtsChallengeMessage(buffer);
    }
    else {
      this->_RtsChallengeMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsChallengeSuccessMessage:
    if (newTag != oldTag) {
      new(&(this->_RtsChallengeSuccessMessage)) Anki::Vector::ExternalComms::RtsChallengeSuccessMessage(buffer);
    }
    else {
      this->_RtsChallengeSuccessMessage.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectRequest)) Anki::Vector::ExternalComms::RtsWifiConnectRequest(buffer);
    }
    else {
      this->_RtsWifiConnectRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiConnectResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiConnectResponse)) Anki::Vector::ExternalComms::RtsWifiConnectResponse(buffer);
    }
    else {
      this->_RtsWifiConnectResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpRequest)) Anki::Vector::ExternalComms::RtsWifiIpRequest(buffer);
    }
    else {
      this->_RtsWifiIpRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiIpResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiIpResponse)) Anki::Vector::ExternalComms::RtsWifiIpResponse(buffer);
    }
    else {
      this->_RtsWifiIpResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusRequest)) Anki::Vector::ExternalComms::RtsStatusRequest(buffer);
    }
    else {
      this->_RtsStatusRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsStatusResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsStatusResponse)) Anki::Vector::ExternalComms::RtsStatusResponse(buffer);
    }
    else {
      this->_RtsStatusResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanRequest)) Anki::Vector::ExternalComms::RtsWifiScanRequest(buffer);
    }
    else {
      this->_RtsWifiScanRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiScanResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiScanResponse)) Anki::Vector::ExternalComms::RtsWifiScanResponse(buffer);
    }
    else {
      this->_RtsWifiScanResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateRequest)) Anki::Vector::ExternalComms::RtsOtaUpdateRequest(buffer);
    }
    else {
      this->_RtsOtaUpdateRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsOtaUpdateResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsOtaUpdateResponse)) Anki::Vector::ExternalComms::RtsOtaUpdateResponse(buffer);
    }
    else {
      this->_RtsOtaUpdateResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsCancelPairing:
    if (newTag != oldTag) {
      new(&(this->_RtsCancelPairing)) Anki::Vector::ExternalComms::RtsCancelPairing(buffer);
    }
    else {
      this->_RtsCancelPairing.Unpack(buffer);
    }
    break;
  case Tag::RtsForceDisconnect:
    if (newTag != oldTag) {
      new(&(this->_RtsForceDisconnect)) Anki::Vector::ExternalComms::RtsForceDisconnect(buffer);
    }
    else {
      this->_RtsForceDisconnect.Unpack(buffer);
    }
    break;
  case Tag::RtsAck:
    if (newTag != oldTag) {
      new(&(this->_RtsAck)) Anki::Vector::ExternalComms::RtsAck(buffer);
    }
    else {
      this->_RtsAck.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointRequest)) Anki::Vector::ExternalComms::RtsWifiAccessPointRequest(buffer);
    }
    else {
      this->_RtsWifiAccessPointRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsWifiAccessPointResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsWifiAccessPointResponse)) Anki::Vector::ExternalComms::RtsWifiAccessPointResponse(buffer);
    }
    else {
      this->_RtsWifiAccessPointResponse.Unpack(buffer);
    }
    break;
  case Tag::RtsSshRequest:
    if (newTag != oldTag) {
      new(&(this->_RtsSshRequest)) Anki::Vector::ExternalComms::RtsSshRequest(buffer);
    }
    else {
      this->_RtsSshRequest.Unpack(buffer);
    }
    break;
  case Tag::RtsSshResponse:
    if (newTag != oldTag) {
      new(&(this->_RtsSshResponse)) Anki::Vector::ExternalComms::RtsSshResponse(buffer);
    }
    else {
      this->_RtsSshResponse.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection_1::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection_1::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnRequest:
    this->_RtsConnRequest.Pack(buffer);
    break;
  case Tag::RtsConnResponse:
    this->_RtsConnResponse.Pack(buffer);
    break;
  case Tag::RtsNonceMessage:
    this->_RtsNonceMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeMessage:
    this->_RtsChallengeMessage.Pack(buffer);
    break;
  case Tag::RtsChallengeSuccessMessage:
    this->_RtsChallengeSuccessMessage.Pack(buffer);
    break;
  case Tag::RtsWifiConnectRequest:
    this->_RtsWifiConnectRequest.Pack(buffer);
    break;
  case Tag::RtsWifiConnectResponse:
    this->_RtsWifiConnectResponse.Pack(buffer);
    break;
  case Tag::RtsWifiIpRequest:
    this->_RtsWifiIpRequest.Pack(buffer);
    break;
  case Tag::RtsWifiIpResponse:
    this->_RtsWifiIpResponse.Pack(buffer);
    break;
  case Tag::RtsStatusRequest:
    this->_RtsStatusRequest.Pack(buffer);
    break;
  case Tag::RtsStatusResponse:
    this->_RtsStatusResponse.Pack(buffer);
    break;
  case Tag::RtsWifiScanRequest:
    this->_RtsWifiScanRequest.Pack(buffer);
    break;
  case Tag::RtsWifiScanResponse:
    this->_RtsWifiScanResponse.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateRequest:
    this->_RtsOtaUpdateRequest.Pack(buffer);
    break;
  case Tag::RtsOtaUpdateResponse:
    this->_RtsOtaUpdateResponse.Pack(buffer);
    break;
  case Tag::RtsCancelPairing:
    this->_RtsCancelPairing.Pack(buffer);
    break;
  case Tag::RtsForceDisconnect:
    this->_RtsForceDisconnect.Pack(buffer);
    break;
  case Tag::RtsAck:
    this->_RtsAck.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointRequest:
    this->_RtsWifiAccessPointRequest.Pack(buffer);
    break;
  case Tag::RtsWifiAccessPointResponse:
    this->_RtsWifiAccessPointResponse.Pack(buffer);
    break;
  case Tag::RtsSshRequest:
    this->_RtsSshRequest.Pack(buffer);
    break;
  case Tag::RtsSshResponse:
    this->_RtsSshResponse.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection_1::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnRequest:
    result += this->_RtsConnRequest.Size(); // RtsConnRequest
    break;
  case Tag::RtsConnResponse:
    result += this->_RtsConnResponse.Size(); // RtsConnResponse
    break;
  case Tag::RtsNonceMessage:
    result += this->_RtsNonceMessage.Size(); // RtsNonceMessage
    break;
  case Tag::RtsChallengeMessage:
    result += this->_RtsChallengeMessage.Size(); // RtsChallengeMessage
    break;
  case Tag::RtsChallengeSuccessMessage:
    result += this->_RtsChallengeSuccessMessage.Size(); // RtsChallengeSuccessMessage
    break;
  case Tag::RtsWifiConnectRequest:
    result += this->_RtsWifiConnectRequest.Size(); // RtsWifiConnectRequest
    break;
  case Tag::RtsWifiConnectResponse:
    result += this->_RtsWifiConnectResponse.Size(); // RtsWifiConnectResponse
    break;
  case Tag::RtsWifiIpRequest:
    result += this->_RtsWifiIpRequest.Size(); // RtsWifiIpRequest
    break;
  case Tag::RtsWifiIpResponse:
    result += this->_RtsWifiIpResponse.Size(); // RtsWifiIpResponse
    break;
  case Tag::RtsStatusRequest:
    result += this->_RtsStatusRequest.Size(); // RtsStatusRequest
    break;
  case Tag::RtsStatusResponse:
    result += this->_RtsStatusResponse.Size(); // RtsStatusResponse
    break;
  case Tag::RtsWifiScanRequest:
    result += this->_RtsWifiScanRequest.Size(); // RtsWifiScanRequest
    break;
  case Tag::RtsWifiScanResponse:
    result += this->_RtsWifiScanResponse.Size(); // RtsWifiScanResponse
    break;
  case Tag::RtsOtaUpdateRequest:
    result += this->_RtsOtaUpdateRequest.Size(); // RtsOtaUpdateRequest
    break;
  case Tag::RtsOtaUpdateResponse:
    result += this->_RtsOtaUpdateResponse.Size(); // RtsOtaUpdateResponse
    break;
  case Tag::RtsCancelPairing:
    result += this->_RtsCancelPairing.Size(); // RtsCancelPairing
    break;
  case Tag::RtsForceDisconnect:
    result += this->_RtsForceDisconnect.Size(); // RtsForceDisconnect
    break;
  case Tag::RtsAck:
    result += this->_RtsAck.Size(); // RtsAck
    break;
  case Tag::RtsWifiAccessPointRequest:
    result += this->_RtsWifiAccessPointRequest.Size(); // RtsWifiAccessPointRequest
    break;
  case Tag::RtsWifiAccessPointResponse:
    result += this->_RtsWifiAccessPointResponse.Size(); // RtsWifiAccessPointResponse
    break;
  case Tag::RtsSshRequest:
    result += this->_RtsSshRequest.Size(); // RtsSshRequest
    break;
  case Tag::RtsSshResponse:
    result += this->_RtsSshResponse.Size(); // RtsSshResponse
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection_1::operator==(const RtsConnection_1& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnRequest:
    return this->_RtsConnRequest == other._RtsConnRequest;
  case Tag::RtsConnResponse:
    return this->_RtsConnResponse == other._RtsConnResponse;
  case Tag::RtsNonceMessage:
    return this->_RtsNonceMessage == other._RtsNonceMessage;
  case Tag::RtsChallengeMessage:
    return this->_RtsChallengeMessage == other._RtsChallengeMessage;
  case Tag::RtsChallengeSuccessMessage:
    return this->_RtsChallengeSuccessMessage == other._RtsChallengeSuccessMessage;
  case Tag::RtsWifiConnectRequest:
    return this->_RtsWifiConnectRequest == other._RtsWifiConnectRequest;
  case Tag::RtsWifiConnectResponse:
    return this->_RtsWifiConnectResponse == other._RtsWifiConnectResponse;
  case Tag::RtsWifiIpRequest:
    return this->_RtsWifiIpRequest == other._RtsWifiIpRequest;
  case Tag::RtsWifiIpResponse:
    return this->_RtsWifiIpResponse == other._RtsWifiIpResponse;
  case Tag::RtsStatusRequest:
    return this->_RtsStatusRequest == other._RtsStatusRequest;
  case Tag::RtsStatusResponse:
    return this->_RtsStatusResponse == other._RtsStatusResponse;
  case Tag::RtsWifiScanRequest:
    return this->_RtsWifiScanRequest == other._RtsWifiScanRequest;
  case Tag::RtsWifiScanResponse:
    return this->_RtsWifiScanResponse == other._RtsWifiScanResponse;
  case Tag::RtsOtaUpdateRequest:
    return this->_RtsOtaUpdateRequest == other._RtsOtaUpdateRequest;
  case Tag::RtsOtaUpdateResponse:
    return this->_RtsOtaUpdateResponse == other._RtsOtaUpdateResponse;
  case Tag::RtsCancelPairing:
    return this->_RtsCancelPairing == other._RtsCancelPairing;
  case Tag::RtsForceDisconnect:
    return this->_RtsForceDisconnect == other._RtsForceDisconnect;
  case Tag::RtsAck:
    return this->_RtsAck == other._RtsAck;
  case Tag::RtsWifiAccessPointRequest:
    return this->_RtsWifiAccessPointRequest == other._RtsWifiAccessPointRequest;
  case Tag::RtsWifiAccessPointResponse:
    return this->_RtsWifiAccessPointResponse == other._RtsWifiAccessPointResponse;
  case Tag::RtsSshRequest:
    return this->_RtsSshRequest == other._RtsSshRequest;
  case Tag::RtsSshResponse:
    return this->_RtsSshResponse == other._RtsSshResponse;
  default:
    return true;
  }
}

bool RtsConnection_1::operator!=(const RtsConnection_1& other) const
{
  return !(operator==(other));
}

void RtsConnection_1::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnRequest:
    _RtsConnRequest.~RtsConnRequest();
    break;
  case Tag::RtsConnResponse:
    _RtsConnResponse.~RtsConnResponse();
    break;
  case Tag::RtsNonceMessage:
    _RtsNonceMessage.~RtsNonceMessage();
    break;
  case Tag::RtsChallengeMessage:
    _RtsChallengeMessage.~RtsChallengeMessage();
    break;
  case Tag::RtsChallengeSuccessMessage:
    _RtsChallengeSuccessMessage.~RtsChallengeSuccessMessage();
    break;
  case Tag::RtsWifiConnectRequest:
    _RtsWifiConnectRequest.~RtsWifiConnectRequest();
    break;
  case Tag::RtsWifiConnectResponse:
    _RtsWifiConnectResponse.~RtsWifiConnectResponse();
    break;
  case Tag::RtsWifiIpRequest:
    _RtsWifiIpRequest.~RtsWifiIpRequest();
    break;
  case Tag::RtsWifiIpResponse:
    _RtsWifiIpResponse.~RtsWifiIpResponse();
    break;
  case Tag::RtsStatusRequest:
    _RtsStatusRequest.~RtsStatusRequest();
    break;
  case Tag::RtsStatusResponse:
    _RtsStatusResponse.~RtsStatusResponse();
    break;
  case Tag::RtsWifiScanRequest:
    _RtsWifiScanRequest.~RtsWifiScanRequest();
    break;
  case Tag::RtsWifiScanResponse:
    _RtsWifiScanResponse.~RtsWifiScanResponse();
    break;
  case Tag::RtsOtaUpdateRequest:
    _RtsOtaUpdateRequest.~RtsOtaUpdateRequest();
    break;
  case Tag::RtsOtaUpdateResponse:
    _RtsOtaUpdateResponse.~RtsOtaUpdateResponse();
    break;
  case Tag::RtsCancelPairing:
    _RtsCancelPairing.~RtsCancelPairing();
    break;
  case Tag::RtsForceDisconnect:
    _RtsForceDisconnect.~RtsForceDisconnect();
    break;
  case Tag::RtsAck:
    _RtsAck.~RtsAck();
    break;
  case Tag::RtsWifiAccessPointRequest:
    _RtsWifiAccessPointRequest.~RtsWifiAccessPointRequest();
    break;
  case Tag::RtsWifiAccessPointResponse:
    _RtsWifiAccessPointResponse.~RtsWifiAccessPointResponse();
    break;
  case Tag::RtsSshRequest:
    _RtsSshRequest.~RtsSshRequest();
    break;
  case Tag::RtsSshResponse:
    _RtsSshResponse.~RtsSshResponse();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnection_1TagToString(const RtsConnection_1Tag tag) {
  switch(tag) {
  case RtsConnection_1Tag::Error:
    return "Error";
  case RtsConnection_1Tag::RtsConnRequest:
    return "RtsConnRequest";
  case RtsConnection_1Tag::RtsConnResponse:
    return "RtsConnResponse";
  case RtsConnection_1Tag::RtsNonceMessage:
    return "RtsNonceMessage";
  case RtsConnection_1Tag::RtsChallengeMessage:
    return "RtsChallengeMessage";
  case RtsConnection_1Tag::RtsChallengeSuccessMessage:
    return "RtsChallengeSuccessMessage";
  case RtsConnection_1Tag::RtsWifiConnectRequest:
    return "RtsWifiConnectRequest";
  case RtsConnection_1Tag::RtsWifiConnectResponse:
    return "RtsWifiConnectResponse";
  case RtsConnection_1Tag::RtsWifiIpRequest:
    return "RtsWifiIpRequest";
  case RtsConnection_1Tag::RtsWifiIpResponse:
    return "RtsWifiIpResponse";
  case RtsConnection_1Tag::RtsStatusRequest:
    return "RtsStatusRequest";
  case RtsConnection_1Tag::RtsStatusResponse:
    return "RtsStatusResponse";
  case RtsConnection_1Tag::RtsWifiScanRequest:
    return "RtsWifiScanRequest";
  case RtsConnection_1Tag::RtsWifiScanResponse:
    return "RtsWifiScanResponse";
  case RtsConnection_1Tag::RtsOtaUpdateRequest:
    return "RtsOtaUpdateRequest";
  case RtsConnection_1Tag::RtsOtaUpdateResponse:
    return "RtsOtaUpdateResponse";
  case RtsConnection_1Tag::RtsCancelPairing:
    return "RtsCancelPairing";
  case RtsConnection_1Tag::RtsForceDisconnect:
    return "RtsForceDisconnect";
  case RtsConnection_1Tag::RtsAck:
    return "RtsAck";
  case RtsConnection_1Tag::RtsWifiAccessPointRequest:
    return "RtsWifiAccessPointRequest";
  case RtsConnection_1Tag::RtsWifiAccessPointResponse:
    return "RtsWifiAccessPointResponse";
  case RtsConnection_1Tag::RtsSshRequest:
    return "RtsSshRequest";
  case RtsConnection_1Tag::RtsSshResponse:
    return "RtsSshResponse";
  default:
    return "INVALID";
  }
}

const char* RtsConnection_1VersionHashStr = "4bf0c4ef0a787465818e85c24ce2bb75";

const uint8_t RtsConnection_1VersionHash[16] = { 
    0x4b, 0xf0, 0xc4, 0xef, 0xa, 0x78, 0x74, 0x65, 0x81, 0x8e, 0x85, 0xc2, 0x4c, 0xe2, 0xbb, 0x75 
};

// UNION RtsConnection

RtsConnection::RtsConnection(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

RtsConnection::RtsConnection(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

RtsConnection::RtsConnection(const RtsConnection& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnection_2:
    new(&(this->_RtsConnection_2)) Anki::Vector::ExternalComms::RtsConnection_2(other._RtsConnection_2);
    break;
  case Tag::RtsConnection_3:
    new(&(this->_RtsConnection_3)) Anki::Vector::ExternalComms::RtsConnection_3(other._RtsConnection_3);
    break;
  case Tag::RtsConnection_4:
    new(&(this->_RtsConnection_4)) Anki::Vector::ExternalComms::RtsConnection_4(other._RtsConnection_4);
    break;
  case Tag::RtsConnection_5:
    new(&(this->_RtsConnection_5)) Anki::Vector::ExternalComms::RtsConnection_5(other._RtsConnection_5);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

RtsConnection::RtsConnection(RtsConnection&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnection_2:
    new(&(this->_RtsConnection_2)) Anki::Vector::ExternalComms::RtsConnection_2(std::move(other._RtsConnection_2));
    break;
  case Tag::RtsConnection_3:
    new(&(this->_RtsConnection_3)) Anki::Vector::ExternalComms::RtsConnection_3(std::move(other._RtsConnection_3));
    break;
  case Tag::RtsConnection_4:
    new(&(this->_RtsConnection_4)) Anki::Vector::ExternalComms::RtsConnection_4(std::move(other._RtsConnection_4));
    break;
  case Tag::RtsConnection_5:
    new(&(this->_RtsConnection_5)) Anki::Vector::ExternalComms::RtsConnection_5(std::move(other._RtsConnection_5));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

RtsConnection& RtsConnection::operator=(const RtsConnection& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnection_2:
    new(&(this->_RtsConnection_2)) Anki::Vector::ExternalComms::RtsConnection_2(other._RtsConnection_2);
    break;
  case Tag::RtsConnection_3:
    new(&(this->_RtsConnection_3)) Anki::Vector::ExternalComms::RtsConnection_3(other._RtsConnection_3);
    break;
  case Tag::RtsConnection_4:
    new(&(this->_RtsConnection_4)) Anki::Vector::ExternalComms::RtsConnection_4(other._RtsConnection_4);
    break;
  case Tag::RtsConnection_5:
    new(&(this->_RtsConnection_5)) Anki::Vector::ExternalComms::RtsConnection_5(other._RtsConnection_5);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

RtsConnection& RtsConnection::operator=(RtsConnection&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnection_2:
    new(&(this->_RtsConnection_2)) Anki::Vector::ExternalComms::RtsConnection_2(std::move(other._RtsConnection_2));
    break;
  case Tag::RtsConnection_3:
    new(&(this->_RtsConnection_3)) Anki::Vector::ExternalComms::RtsConnection_3(std::move(other._RtsConnection_3));
    break;
  case Tag::RtsConnection_4:
    new(&(this->_RtsConnection_4)) Anki::Vector::ExternalComms::RtsConnection_4(std::move(other._RtsConnection_4));
    break;
  case Tag::RtsConnection_5:
    new(&(this->_RtsConnection_5)) Anki::Vector::ExternalComms::RtsConnection_5(std::move(other._RtsConnection_5));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

RtsConnection RtsConnection::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  RtsConnection m;
  m.Set_Error(new_Error);
  return m;
}

RtsConnection::RtsConnection(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& RtsConnection::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void RtsConnection::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& RtsConnection::Get_<RtsConnection::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
RtsConnection RtsConnection::Create_<RtsConnection::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void RtsConnection::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

RtsConnection RtsConnection::CreateRtsConnection_2(Anki::Vector::ExternalComms::RtsConnection_2&& new_RtsConnection_2)
{
  RtsConnection m;
  m.Set_RtsConnection_2(new_RtsConnection_2);
  return m;
}

RtsConnection::RtsConnection(Anki::Vector::ExternalComms::RtsConnection_2&& new_RtsConnection_2)
{
  new(&this->_RtsConnection_2) Anki::Vector::ExternalComms::RtsConnection_2(std::move(new_RtsConnection_2));
  _tag = Tag::RtsConnection_2;
}

const Anki::Vector::ExternalComms::RtsConnection_2& RtsConnection::Get_RtsConnection_2() const
{
  assert(_tag == Tag::RtsConnection_2);
  return this->_RtsConnection_2;
}

void RtsConnection::Set_RtsConnection_2(const Anki::Vector::ExternalComms::RtsConnection_2& new_RtsConnection_2)
{
  if(this->_tag == Tag::RtsConnection_2) {
    this->_RtsConnection_2 = new_RtsConnection_2;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_2) Anki::Vector::ExternalComms::RtsConnection_2(new_RtsConnection_2);
    _tag = Tag::RtsConnection_2;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection_2& RtsConnection::Get_<RtsConnection::Tag::RtsConnection_2>() const
{
  assert(_tag == Tag::RtsConnection_2);
  return this->_RtsConnection_2;
}

template<>
RtsConnection RtsConnection::Create_<RtsConnection::Tag::RtsConnection_2>(Anki::Vector::ExternalComms::RtsConnection_2 member)
{
  return CreateRtsConnection_2(std::move(member));
}

void RtsConnection::Set_RtsConnection_2(Anki::Vector::ExternalComms::RtsConnection_2&& new_RtsConnection_2)
{
  if (this->_tag == Tag::RtsConnection_2) {
    this->_RtsConnection_2 = std::move(new_RtsConnection_2);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_2) Anki::Vector::ExternalComms::RtsConnection_2(std::move(new_RtsConnection_2));
    _tag = Tag::RtsConnection_2;
  }
}

RtsConnection RtsConnection::CreateRtsConnection_3(Anki::Vector::ExternalComms::RtsConnection_3&& new_RtsConnection_3)
{
  RtsConnection m;
  m.Set_RtsConnection_3(new_RtsConnection_3);
  return m;
}

RtsConnection::RtsConnection(Anki::Vector::ExternalComms::RtsConnection_3&& new_RtsConnection_3)
{
  new(&this->_RtsConnection_3) Anki::Vector::ExternalComms::RtsConnection_3(std::move(new_RtsConnection_3));
  _tag = Tag::RtsConnection_3;
}

const Anki::Vector::ExternalComms::RtsConnection_3& RtsConnection::Get_RtsConnection_3() const
{
  assert(_tag == Tag::RtsConnection_3);
  return this->_RtsConnection_3;
}

void RtsConnection::Set_RtsConnection_3(const Anki::Vector::ExternalComms::RtsConnection_3& new_RtsConnection_3)
{
  if(this->_tag == Tag::RtsConnection_3) {
    this->_RtsConnection_3 = new_RtsConnection_3;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_3) Anki::Vector::ExternalComms::RtsConnection_3(new_RtsConnection_3);
    _tag = Tag::RtsConnection_3;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection_3& RtsConnection::Get_<RtsConnection::Tag::RtsConnection_3>() const
{
  assert(_tag == Tag::RtsConnection_3);
  return this->_RtsConnection_3;
}

template<>
RtsConnection RtsConnection::Create_<RtsConnection::Tag::RtsConnection_3>(Anki::Vector::ExternalComms::RtsConnection_3 member)
{
  return CreateRtsConnection_3(std::move(member));
}

void RtsConnection::Set_RtsConnection_3(Anki::Vector::ExternalComms::RtsConnection_3&& new_RtsConnection_3)
{
  if (this->_tag == Tag::RtsConnection_3) {
    this->_RtsConnection_3 = std::move(new_RtsConnection_3);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_3) Anki::Vector::ExternalComms::RtsConnection_3(std::move(new_RtsConnection_3));
    _tag = Tag::RtsConnection_3;
  }
}

RtsConnection RtsConnection::CreateRtsConnection_4(Anki::Vector::ExternalComms::RtsConnection_4&& new_RtsConnection_4)
{
  RtsConnection m;
  m.Set_RtsConnection_4(new_RtsConnection_4);
  return m;
}

RtsConnection::RtsConnection(Anki::Vector::ExternalComms::RtsConnection_4&& new_RtsConnection_4)
{
  new(&this->_RtsConnection_4) Anki::Vector::ExternalComms::RtsConnection_4(std::move(new_RtsConnection_4));
  _tag = Tag::RtsConnection_4;
}

const Anki::Vector::ExternalComms::RtsConnection_4& RtsConnection::Get_RtsConnection_4() const
{
  assert(_tag == Tag::RtsConnection_4);
  return this->_RtsConnection_4;
}

void RtsConnection::Set_RtsConnection_4(const Anki::Vector::ExternalComms::RtsConnection_4& new_RtsConnection_4)
{
  if(this->_tag == Tag::RtsConnection_4) {
    this->_RtsConnection_4 = new_RtsConnection_4;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_4) Anki::Vector::ExternalComms::RtsConnection_4(new_RtsConnection_4);
    _tag = Tag::RtsConnection_4;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection_4& RtsConnection::Get_<RtsConnection::Tag::RtsConnection_4>() const
{
  assert(_tag == Tag::RtsConnection_4);
  return this->_RtsConnection_4;
}

template<>
RtsConnection RtsConnection::Create_<RtsConnection::Tag::RtsConnection_4>(Anki::Vector::ExternalComms::RtsConnection_4 member)
{
  return CreateRtsConnection_4(std::move(member));
}

void RtsConnection::Set_RtsConnection_4(Anki::Vector::ExternalComms::RtsConnection_4&& new_RtsConnection_4)
{
  if (this->_tag == Tag::RtsConnection_4) {
    this->_RtsConnection_4 = std::move(new_RtsConnection_4);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_4) Anki::Vector::ExternalComms::RtsConnection_4(std::move(new_RtsConnection_4));
    _tag = Tag::RtsConnection_4;
  }
}

RtsConnection RtsConnection::CreateRtsConnection_5(Anki::Vector::ExternalComms::RtsConnection_5&& new_RtsConnection_5)
{
  RtsConnection m;
  m.Set_RtsConnection_5(new_RtsConnection_5);
  return m;
}

RtsConnection::RtsConnection(Anki::Vector::ExternalComms::RtsConnection_5&& new_RtsConnection_5)
{
  new(&this->_RtsConnection_5) Anki::Vector::ExternalComms::RtsConnection_5(std::move(new_RtsConnection_5));
  _tag = Tag::RtsConnection_5;
}

const Anki::Vector::ExternalComms::RtsConnection_5& RtsConnection::Get_RtsConnection_5() const
{
  assert(_tag == Tag::RtsConnection_5);
  return this->_RtsConnection_5;
}

void RtsConnection::Set_RtsConnection_5(const Anki::Vector::ExternalComms::RtsConnection_5& new_RtsConnection_5)
{
  if(this->_tag == Tag::RtsConnection_5) {
    this->_RtsConnection_5 = new_RtsConnection_5;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_5) Anki::Vector::ExternalComms::RtsConnection_5(new_RtsConnection_5);
    _tag = Tag::RtsConnection_5;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection_5& RtsConnection::Get_<RtsConnection::Tag::RtsConnection_5>() const
{
  assert(_tag == Tag::RtsConnection_5);
  return this->_RtsConnection_5;
}

template<>
RtsConnection RtsConnection::Create_<RtsConnection::Tag::RtsConnection_5>(Anki::Vector::ExternalComms::RtsConnection_5 member)
{
  return CreateRtsConnection_5(std::move(member));
}

void RtsConnection::Set_RtsConnection_5(Anki::Vector::ExternalComms::RtsConnection_5&& new_RtsConnection_5)
{
  if (this->_tag == Tag::RtsConnection_5) {
    this->_RtsConnection_5 = std::move(new_RtsConnection_5);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_5) Anki::Vector::ExternalComms::RtsConnection_5(std::move(new_RtsConnection_5));
    _tag = Tag::RtsConnection_5;
  }
}

size_t RtsConnection::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t RtsConnection::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection_2:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection_2)) Anki::Vector::ExternalComms::RtsConnection_2(buffer);
    }
    else {
      this->_RtsConnection_2.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection_3:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection_3)) Anki::Vector::ExternalComms::RtsConnection_3(buffer);
    }
    else {
      this->_RtsConnection_3.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection_4:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection_4)) Anki::Vector::ExternalComms::RtsConnection_4(buffer);
    }
    else {
      this->_RtsConnection_4.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection_5:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection_5)) Anki::Vector::ExternalComms::RtsConnection_5(buffer);
    }
    else {
      this->_RtsConnection_5.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t RtsConnection::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t RtsConnection::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnection_2:
    this->_RtsConnection_2.Pack(buffer);
    break;
  case Tag::RtsConnection_3:
    this->_RtsConnection_3.Pack(buffer);
    break;
  case Tag::RtsConnection_4:
    this->_RtsConnection_4.Pack(buffer);
    break;
  case Tag::RtsConnection_5:
    this->_RtsConnection_5.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t RtsConnection::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnection_2:
    result += this->_RtsConnection_2.Size(); // RtsConnection_2
    break;
  case Tag::RtsConnection_3:
    result += this->_RtsConnection_3.Size(); // RtsConnection_3
    break;
  case Tag::RtsConnection_4:
    result += this->_RtsConnection_4.Size(); // RtsConnection_4
    break;
  case Tag::RtsConnection_5:
    result += this->_RtsConnection_5.Size(); // RtsConnection_5
    break;
  default:
    break;
  }
  return result;
}

bool RtsConnection::operator==(const RtsConnection& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnection_2:
    return this->_RtsConnection_2 == other._RtsConnection_2;
  case Tag::RtsConnection_3:
    return this->_RtsConnection_3 == other._RtsConnection_3;
  case Tag::RtsConnection_4:
    return this->_RtsConnection_4 == other._RtsConnection_4;
  case Tag::RtsConnection_5:
    return this->_RtsConnection_5 == other._RtsConnection_5;
  default:
    return true;
  }
}

bool RtsConnection::operator!=(const RtsConnection& other) const
{
  return !(operator==(other));
}

void RtsConnection::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnection_2:
    _RtsConnection_2.~RtsConnection_2();
    break;
  case Tag::RtsConnection_3:
    _RtsConnection_3.~RtsConnection_3();
    break;
  case Tag::RtsConnection_4:
    _RtsConnection_4.~RtsConnection_4();
    break;
  case Tag::RtsConnection_5:
    _RtsConnection_5.~RtsConnection_5();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* RtsConnectionTagToString(const RtsConnectionTag tag) {
  switch(tag) {
  case RtsConnectionTag::Error:
    return "Error";
  case RtsConnectionTag::RtsConnection_2:
    return "RtsConnection_2";
  case RtsConnectionTag::RtsConnection_3:
    return "RtsConnection_3";
  case RtsConnectionTag::RtsConnection_4:
    return "RtsConnection_4";
  case RtsConnectionTag::RtsConnection_5:
    return "RtsConnection_5";
  default:
    return "INVALID";
  }
}

const char* RtsConnectionVersionHashStr = "2217698cbf21891a51f8051642293741";

const uint8_t RtsConnectionVersionHash[16] = { 
    0x22, 0x17, 0x69, 0x8c, 0xbf, 0x21, 0x89, 0x1a, 0x51, 0xf8, 0x5, 0x16, 0x42, 0x29, 0x37, 0x41 
};

// MESSAGE DeprecatedAndReserved

DeprecatedAndReserved::DeprecatedAndReserved(const CLAD::SafeMessageBuffer& buffer)

{
  Unpack(buffer);
}

DeprecatedAndReserved::DeprecatedAndReserved(const uint8_t* buff, size_t len)
: DeprecatedAndReserved::DeprecatedAndReserved({const_cast<uint8_t*>(buff), len, false})
{
}

size_t DeprecatedAndReserved::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t DeprecatedAndReserved::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  const size_t bytesWritten {buffer.GetBytesWritten()};
  return bytesWritten;
}

size_t DeprecatedAndReserved::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t DeprecatedAndReserved::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  return buffer.GetBytesRead();
}

size_t DeprecatedAndReserved::Size() const
{
  size_t result = 0;
  return result;
}

bool DeprecatedAndReserved::operator==(const DeprecatedAndReserved& other) const
{
return true;
}

bool DeprecatedAndReserved::operator!=(const DeprecatedAndReserved& other) const
{
  return !(operator==(other));
}


const char* DeprecatedAndReservedVersionHashStr = "4b3ebb49cedecb2c58f78f4fe36b8459";

const uint8_t DeprecatedAndReservedVersionHash[16] = { 
    0x4b, 0x3e, 0xbb, 0x49, 0xce, 0xde, 0xcb, 0x2c, 0x58, 0xf7, 0x8f, 0x4f, 0xe3, 0x6b, 0x84, 0x59 
};

// UNION ExternalComms

ExternalComms::ExternalComms(const CLAD::SafeMessageBuffer& buff)
: _tag(Tag::INVALID)
{
  Unpack(buff);
}

ExternalComms::ExternalComms(const uint8_t* buffer, size_t length)
: _tag(Tag::INVALID)
{
  CLAD::SafeMessageBuffer buff(const_cast<uint8_t*>(buffer), length);
  Unpack(buff);
}

ExternalComms::ExternalComms(const ExternalComms& other)
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnection_1:
    new(&(this->_RtsConnection_1)) Anki::Vector::ExternalComms::RtsConnection_1(other._RtsConnection_1);
    break;
  case Tag::RtsConnection:
    new(&(this->_RtsConnection)) Anki::Vector::ExternalComms::RtsConnection(other._RtsConnection);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
}

ExternalComms::ExternalComms(ExternalComms&& other) noexcept
: _tag(other._tag)
{
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnection_1:
    new(&(this->_RtsConnection_1)) Anki::Vector::ExternalComms::RtsConnection_1(std::move(other._RtsConnection_1));
    break;
  case Tag::RtsConnection:
    new(&(this->_RtsConnection)) Anki::Vector::ExternalComms::RtsConnection(std::move(other._RtsConnection));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
}

ExternalComms& ExternalComms::operator=(const ExternalComms& other)
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(other._Error);
    break;
  case Tag::RtsConnection_1:
    new(&(this->_RtsConnection_1)) Anki::Vector::ExternalComms::RtsConnection_1(other._RtsConnection_1);
    break;
  case Tag::RtsConnection:
    new(&(this->_RtsConnection)) Anki::Vector::ExternalComms::RtsConnection(other._RtsConnection);
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  return *this;
}

ExternalComms& ExternalComms::operator=(ExternalComms&& other) noexcept
{
  if(this == &other) { return *this; }
  ClearCurrent();
  _tag = other._tag;
  switch(GetTag()) {
  case Tag::Error:
    new(&(this->_Error)) Anki::Vector::ExternalComms::Error(std::move(other._Error));
    break;
  case Tag::RtsConnection_1:
    new(&(this->_RtsConnection_1)) Anki::Vector::ExternalComms::RtsConnection_1(std::move(other._RtsConnection_1));
    break;
  case Tag::RtsConnection:
    new(&(this->_RtsConnection)) Anki::Vector::ExternalComms::RtsConnection(std::move(other._RtsConnection));
    break;
  default:
    _tag = Tag::INVALID;
    break;
  }
  other.ClearCurrent();
  return *this;
}

ExternalComms ExternalComms::CreateError(Anki::Vector::ExternalComms::Error&& new_Error)
{
  ExternalComms m;
  m.Set_Error(new_Error);
  return m;
}

ExternalComms::ExternalComms(Anki::Vector::ExternalComms::Error&& new_Error)
{
  new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
  _tag = Tag::Error;
}

const Anki::Vector::ExternalComms::Error& ExternalComms::Get_Error() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

void ExternalComms::Set_Error(const Anki::Vector::ExternalComms::Error& new_Error)
{
  if(this->_tag == Tag::Error) {
    this->_Error = new_Error;
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(new_Error);
    _tag = Tag::Error;
  }
}

template<>
const Anki::Vector::ExternalComms::Error& ExternalComms::Get_<ExternalComms::Tag::Error>() const
{
  assert(_tag == Tag::Error);
  return this->_Error;
}

template<>
ExternalComms ExternalComms::Create_<ExternalComms::Tag::Error>(Anki::Vector::ExternalComms::Error member)
{
  return CreateError(std::move(member));
}

void ExternalComms::Set_Error(Anki::Vector::ExternalComms::Error&& new_Error)
{
  if (this->_tag == Tag::Error) {
    this->_Error = std::move(new_Error);
  }
  else {
    ClearCurrent();
    new(&this->_Error) Anki::Vector::ExternalComms::Error(std::move(new_Error));
    _tag = Tag::Error;
  }
}

ExternalComms ExternalComms::CreateRtsConnection_1(Anki::Vector::ExternalComms::RtsConnection_1&& new_RtsConnection_1)
{
  ExternalComms m;
  m.Set_RtsConnection_1(new_RtsConnection_1);
  return m;
}

ExternalComms::ExternalComms(Anki::Vector::ExternalComms::RtsConnection_1&& new_RtsConnection_1)
{
  new(&this->_RtsConnection_1) Anki::Vector::ExternalComms::RtsConnection_1(std::move(new_RtsConnection_1));
  _tag = Tag::RtsConnection_1;
}

const Anki::Vector::ExternalComms::RtsConnection_1& ExternalComms::Get_RtsConnection_1() const
{
  assert(_tag == Tag::RtsConnection_1);
  return this->_RtsConnection_1;
}

void ExternalComms::Set_RtsConnection_1(const Anki::Vector::ExternalComms::RtsConnection_1& new_RtsConnection_1)
{
  if(this->_tag == Tag::RtsConnection_1) {
    this->_RtsConnection_1 = new_RtsConnection_1;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_1) Anki::Vector::ExternalComms::RtsConnection_1(new_RtsConnection_1);
    _tag = Tag::RtsConnection_1;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection_1& ExternalComms::Get_<ExternalComms::Tag::RtsConnection_1>() const
{
  assert(_tag == Tag::RtsConnection_1);
  return this->_RtsConnection_1;
}

template<>
ExternalComms ExternalComms::Create_<ExternalComms::Tag::RtsConnection_1>(Anki::Vector::ExternalComms::RtsConnection_1 member)
{
  return CreateRtsConnection_1(std::move(member));
}

void ExternalComms::Set_RtsConnection_1(Anki::Vector::ExternalComms::RtsConnection_1&& new_RtsConnection_1)
{
  if (this->_tag == Tag::RtsConnection_1) {
    this->_RtsConnection_1 = std::move(new_RtsConnection_1);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection_1) Anki::Vector::ExternalComms::RtsConnection_1(std::move(new_RtsConnection_1));
    _tag = Tag::RtsConnection_1;
  }
}

ExternalComms ExternalComms::CreateRtsConnection(Anki::Vector::ExternalComms::RtsConnection&& new_RtsConnection)
{
  ExternalComms m;
  m.Set_RtsConnection(new_RtsConnection);
  return m;
}

ExternalComms::ExternalComms(Anki::Vector::ExternalComms::RtsConnection&& new_RtsConnection)
{
  new(&this->_RtsConnection) Anki::Vector::ExternalComms::RtsConnection(std::move(new_RtsConnection));
  _tag = Tag::RtsConnection;
}

const Anki::Vector::ExternalComms::RtsConnection& ExternalComms::Get_RtsConnection() const
{
  assert(_tag == Tag::RtsConnection);
  return this->_RtsConnection;
}

void ExternalComms::Set_RtsConnection(const Anki::Vector::ExternalComms::RtsConnection& new_RtsConnection)
{
  if(this->_tag == Tag::RtsConnection) {
    this->_RtsConnection = new_RtsConnection;
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection) Anki::Vector::ExternalComms::RtsConnection(new_RtsConnection);
    _tag = Tag::RtsConnection;
  }
}

template<>
const Anki::Vector::ExternalComms::RtsConnection& ExternalComms::Get_<ExternalComms::Tag::RtsConnection>() const
{
  assert(_tag == Tag::RtsConnection);
  return this->_RtsConnection;
}

template<>
ExternalComms ExternalComms::Create_<ExternalComms::Tag::RtsConnection>(Anki::Vector::ExternalComms::RtsConnection member)
{
  return CreateRtsConnection(std::move(member));
}

void ExternalComms::Set_RtsConnection(Anki::Vector::ExternalComms::RtsConnection&& new_RtsConnection)
{
  if (this->_tag == Tag::RtsConnection) {
    this->_RtsConnection = std::move(new_RtsConnection);
  }
  else {
    ClearCurrent();
    new(&this->_RtsConnection) Anki::Vector::ExternalComms::RtsConnection(std::move(new_RtsConnection));
    _tag = Tag::RtsConnection;
  }
}

size_t ExternalComms::Unpack(const uint8_t* buff, const size_t len)
{
  const CLAD::SafeMessageBuffer buffer(const_cast<uint8_t*>(buff), len, false);
  return Unpack(buffer);
}

size_t ExternalComms::Unpack(const CLAD::SafeMessageBuffer& buffer)
{
  Tag newTag {Tag::INVALID};
  const Tag oldTag {GetTag()};
  buffer.Read(newTag);
  if (newTag != oldTag) {
    ClearCurrent();
  }
  switch(newTag) {
  case Tag::Error:
    if (newTag != oldTag) {
      new(&(this->_Error)) Anki::Vector::ExternalComms::Error(buffer);
    }
    else {
      this->_Error.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection_1:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection_1)) Anki::Vector::ExternalComms::RtsConnection_1(buffer);
    }
    else {
      this->_RtsConnection_1.Unpack(buffer);
    }
    break;
  case Tag::RtsConnection:
    if (newTag != oldTag) {
      new(&(this->_RtsConnection)) Anki::Vector::ExternalComms::RtsConnection(buffer);
    }
    else {
      this->_RtsConnection.Unpack(buffer);
    }
    break;
  default:
    break;
  }
  _tag = newTag;
  return buffer.GetBytesRead();
}

size_t ExternalComms::Pack(uint8_t* buff, size_t len) const
{
  CLAD::SafeMessageBuffer buffer(buff, len, false);
  return Pack(buffer);
}

size_t ExternalComms::Pack(CLAD::SafeMessageBuffer& buffer) const
{
  buffer.Write(_tag);
  switch(GetTag()) {
  case Tag::Error:
    this->_Error.Pack(buffer);
    break;
  case Tag::RtsConnection_1:
    this->_RtsConnection_1.Pack(buffer);
    break;
  case Tag::RtsConnection:
    this->_RtsConnection.Pack(buffer);
    break;
  default:
    break;
  }
  return buffer.GetBytesWritten();
}

size_t ExternalComms::Size() const
{
  size_t result {1}; // tag = uint_8
  switch(GetTag()) {
  case Tag::Error:
    result += this->_Error.Size(); // Error
    break;
  case Tag::RtsConnection_1:
    result += this->_RtsConnection_1.Size(); // RtsConnection_1
    break;
  case Tag::RtsConnection:
    result += this->_RtsConnection.Size(); // RtsConnection
    break;
  default:
    break;
  }
  return result;
}

bool ExternalComms::operator==(const ExternalComms& other) const
{
  if (this->_tag != other._tag) {
    return false;
  }
  switch(GetTag()) {
  case Tag::Error:
    return this->_Error == other._Error;
  case Tag::RtsConnection_1:
    return this->_RtsConnection_1 == other._RtsConnection_1;
  case Tag::RtsConnection:
    return this->_RtsConnection == other._RtsConnection;
  default:
    return true;
  }
}

bool ExternalComms::operator!=(const ExternalComms& other) const
{
  return !(operator==(other));
}

void ExternalComms::ClearCurrent()
{
  switch(GetTag()) {
  case Tag::Error:
    _Error.~Error();
    break;
  case Tag::RtsConnection_1:
    _RtsConnection_1.~RtsConnection_1();
    break;
  case Tag::RtsConnection:
    _RtsConnection.~RtsConnection();
    break;
  default:
    break;
  }
  _tag = Tag::INVALID;
}

const char* ExternalCommsTagToString(const ExternalCommsTag tag) {
  switch(tag) {
  case ExternalCommsTag::Error:
    return "Error";
  case ExternalCommsTag::RtsConnection_1:
    return "RtsConnection_1";
  case ExternalCommsTag::RtsConnection:
    return "RtsConnection";
  default:
    return "INVALID";
  }
}

const char* ExternalCommsVersionHashStr = "6a5cde20e04c502a51f8e2498080c73f";

const uint8_t ExternalCommsVersionHash[16] = { 
    0x6a, 0x5c, 0xde, 0x20, 0xe0, 0x4c, 0x50, 0x2a, 0x51, 0xf8, 0xe2, 0x49, 0x80, 0x80, 0xc7, 0x3f 
};

} // namespace ExternalComms

} // namespace Vector

} // namespace Anki