"""
Autogenerated python message buffer code.
Source: clad/cloud/mic.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/cloud/mic.clad
"""

from __future__ import absolute_import
from __future__ import print_function

def _modify_path():
  import inspect, os, sys
  search_paths = [
    '../..',
    '../../../../victor-clad/tools/message-buffers/support/python',
  ]
  currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe())))
  for search_path in search_paths:
    search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path))))
    if search_path not in sys.path:
      sys.path.insert(0, search_path)
_modify_path()

import msgbuffers

Anki = msgbuffers.Namespace()
Anki.Vector = msgbuffers.Namespace()
Anki.Vector.CloudMic = msgbuffers.Namespace()

from clad.cloud.common import Anki as _Anki
Anki.update(_Anki.deep_clone())

class StreamType(object):
  "Automatically-generated uint_8 enumeration."
  Normal         = 0
  Blackjack      = 1
  KnowledgeGraph = 2

Anki.Vector.CloudMic.StreamType = StreamType
del StreamType


class ErrorType(object):
  "Automatically-generated uint_8 enumeration."
  Server        = 0
  Timeout       = 1
  Json          = 2
  InvalidConfig = 3
  Connecting    = 4
  NewStream     = 5
  Token         = 6
  TLS           = 7
  Connectivity  = 8

Anki.Vector.CloudMic.ErrorType = ErrorType
del ErrorType


class ConnectionCode(object):
  "Automatically-generated uint_8 enumeration."
  Available    = 0
  Connectivity = 1
  Tls          = 2
  Auth         = 3
  Bandwidth    = 4

Anki.Vector.CloudMic.ConnectionCode = ConnectionCode
del ConnectionCode


class StreamOpen(object):
  "Generated message-passing structure."

  __slots__ = (
    '_session', # string[uint_8]
  )

  @property
  def session(self):
    "string[uint_8] session struct property."
    return self._session

  @session.setter
  def session(self, value):
    self._session = msgbuffers.validate_string(
      'StreamOpen.session', value, 255)

  def __init__(self, session=''):
    self.session = session

  @classmethod
  def unpack(cls, buffer):
    "Reads a new StreamOpen from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('StreamOpen.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new StreamOpen from the given BinaryReader."
    _session = reader.read_string('B')
    return cls(_session)

  def pack(self):
    "Writes the current StreamOpen, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current StreamOpen to the given BinaryWriter."
    writer.write_string(self._session, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._session == other._session
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._session, 'B'))

  def __str__(self):
    return '{type}(session={session})'.format(
      type=type(self).__name__,
      session=msgbuffers.shorten_string(self._session))

  def __repr__(self):
    return '{type}(session={session})'.format(
      type=type(self).__name__,
      session=repr(self._session))

Anki.Vector.CloudMic.StreamOpen = StreamOpen
del StreamOpen


class Hotword(object):
  "Generated message-passing structure."

  __slots__ = (
    '_mode',      # Anki.Vector.CloudMic.StreamType
    '_locale',    # string[uint_8]
    '_timezone',  # string[uint_8]
    '_noLogging', # bool
  )

  @property
  def mode(self):
    "Anki.Vector.CloudMic.StreamType mode struct property."
    return self._mode

  @mode.setter
  def mode(self, value):
    self._mode = msgbuffers.validate_integer(
      'Hotword.mode', value, 0, 255)

  @property
  def locale(self):
    "string[uint_8] locale struct property."
    return self._locale

  @locale.setter
  def locale(self, value):
    self._locale = msgbuffers.validate_string(
      'Hotword.locale', value, 255)

  @property
  def timezone(self):
    "string[uint_8] timezone struct property."
    return self._timezone

  @timezone.setter
  def timezone(self, value):
    self._timezone = msgbuffers.validate_string(
      'Hotword.timezone', value, 255)

  @property
  def noLogging(self):
    "bool noLogging struct property."
    return self._noLogging

  @noLogging.setter
  def noLogging(self, value):
    self._noLogging = msgbuffers.validate_bool(
      'Hotword.noLogging', value)

  def __init__(self, mode=Anki.Vector.CloudMic.StreamType.Normal, locale='', timezone='', noLogging=False):
    self.mode = mode
    self.locale = locale
    self.timezone = timezone
    self.noLogging = noLogging

  @classmethod
  def unpack(cls, buffer):
    "Reads a new Hotword from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('Hotword.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new Hotword from the given BinaryReader."
    _mode = reader.read('B')
    _locale = reader.read_string('B')
    _timezone = reader.read_string('B')
    _noLogging = bool(reader.read('b'))
    return cls(_mode, _locale, _timezone, _noLogging)

  def pack(self):
    "Writes the current Hotword, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current Hotword to the given BinaryWriter."
    writer.write(self._mode, 'B')
    writer.write_string(self._locale, 'B')
    writer.write_string(self._timezone, 'B')
    writer.write(int(self._noLogging), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._mode == other._mode and
        self._locale == other._locale and
        self._timezone == other._timezone and
        self._noLogging == other._noLogging)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._mode, 'B') +
      msgbuffers.size_string(self._locale, 'B') +
      msgbuffers.size_string(self._timezone, 'B') +
      msgbuffers.size(self._noLogging, 'b'))

  def __str__(self):
    return '{type}(mode={mode}, locale={locale}, timezone={timezone}, noLogging={noLogging})'.format(
      type=type(self).__name__,
      mode=self._mode,
      locale=msgbuffers.shorten_string(self._locale),
      timezone=msgbuffers.shorten_string(self._timezone),
      noLogging=self._noLogging)

  def __repr__(self):
    return '{type}(mode={mode}, locale={locale}, timezone={timezone}, noLogging={noLogging})'.format(
      type=type(self).__name__,
      mode=repr(self._mode),
      locale=repr(self._locale),
      timezone=repr(self._timezone),
      noLogging=repr(self._noLogging))

Anki.Vector.CloudMic.Hotword = Hotword
del Hotword


class Filename(object):
  "Generated message-passing structure."

  __slots__ = (
    '_file', # string[uint_8]
  )

  @property
  def file(self):
    "string[uint_8] file struct property."
    return self._file

  @file.setter
  def file(self, value):
    self._file = msgbuffers.validate_string(
      'Filename.file', value, 255)

  def __init__(self, file=''):
    self.file = file

  @classmethod
  def unpack(cls, buffer):
    "Reads a new Filename from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('Filename.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new Filename from the given BinaryReader."
    _file = reader.read_string('B')
    return cls(_file)

  def pack(self):
    "Writes the current Filename, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current Filename to the given BinaryWriter."
    writer.write_string(self._file, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._file == other._file
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._file, 'B'))

  def __str__(self):
    return '{type}(file={file})'.format(
      type=type(self).__name__,
      file=msgbuffers.shorten_string(self._file))

  def __repr__(self):
    return '{type}(file={file})'.format(
      type=type(self).__name__,
      file=repr(self._file))

Anki.Vector.CloudMic.Filename = Filename
del Filename


class AudioData(object):
  "Generated message-passing structure."

  __slots__ = (
    '_data', # int_16[uint_16]
  )

  @property
  def data(self):
    "int_16[uint_16] data struct property."
    return self._data

  @data.setter
  def data(self, value):
    self._data = msgbuffers.validate_varray(
      'AudioData.data', value, 65535,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, -32768, 32767))

  def __init__(self, data=()):
    self.data = data

  @classmethod
  def unpack(cls, buffer):
    "Reads a new AudioData from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('AudioData.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new AudioData from the given BinaryReader."
    _data = reader.read_varray('h', 'H')
    return cls(_data)

  def pack(self):
    "Writes the current AudioData, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current AudioData to the given BinaryWriter."
    writer.write_varray(self._data, 'h', 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._data == other._data
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_varray(self._data, 'h', 'H'))

  def __str__(self):
    return '{type}(data={data})'.format(
      type=type(self).__name__,
      data=msgbuffers.shorten_sequence(self._data))

  def __repr__(self):
    return '{type}(data={data})'.format(
      type=type(self).__name__,
      data=repr(self._data))

Anki.Vector.CloudMic.AudioData = AudioData
del AudioData


class IntentResult(object):
  "Generated message-passing structure."

  __slots__ = (
    '_intent',     # string[uint_8]
    '_parameters', # string[uint_16]
    '_metadata',   # string[uint_16]
  )

  @property
  def intent(self):
    "string[uint_8] intent struct property."
    return self._intent

  @intent.setter
  def intent(self, value):
    self._intent = msgbuffers.validate_string(
      'IntentResult.intent', value, 255)

  @property
  def parameters(self):
    "string[uint_16] parameters struct property."
    return self._parameters

  @parameters.setter
  def parameters(self, value):
    self._parameters = msgbuffers.validate_string(
      'IntentResult.parameters', value, 65535)

  @property
  def metadata(self):
    "string[uint_16] metadata struct property."
    return self._metadata

  @metadata.setter
  def metadata(self, value):
    self._metadata = msgbuffers.validate_string(
      'IntentResult.metadata', value, 65535)

  def __init__(self, intent='', parameters='', metadata=''):
    self.intent = intent
    self.parameters = parameters
    self.metadata = metadata

  @classmethod
  def unpack(cls, buffer):
    "Reads a new IntentResult from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('IntentResult.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new IntentResult from the given BinaryReader."
    _intent = reader.read_string('B')
    _parameters = reader.read_string('H')
    _metadata = reader.read_string('H')
    return cls(_intent, _parameters, _metadata)

  def pack(self):
    "Writes the current IntentResult, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current IntentResult to the given BinaryWriter."
    writer.write_string(self._intent, 'B')
    writer.write_string(self._parameters, 'H')
    writer.write_string(self._metadata, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._intent == other._intent and
        self._parameters == other._parameters and
        self._metadata == other._metadata)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_string(self._intent, 'B') +
      msgbuffers.size_string(self._parameters, 'H') +
      msgbuffers.size_string(self._metadata, 'H'))

  def __str__(self):
    return '{type}(intent={intent}, parameters={parameters}, metadata={metadata})'.format(
      type=type(self).__name__,
      intent=msgbuffers.shorten_string(self._intent),
      parameters=msgbuffers.shorten_string(self._parameters),
      metadata=msgbuffers.shorten_string(self._metadata))

  def __repr__(self):
    return '{type}(intent={intent}, parameters={parameters}, metadata={metadata})'.format(
      type=type(self).__name__,
      intent=repr(self._intent),
      parameters=repr(self._parameters),
      metadata=repr(self._metadata))

Anki.Vector.CloudMic.IntentResult = IntentResult
del IntentResult


class IntentError(object):
  "Generated message-passing structure."

  __slots__ = (
    '_error', # Anki.Vector.CloudMic.ErrorType
    '_extra', # string[uint_8]
  )

  @property
  def error(self):
    "Anki.Vector.CloudMic.ErrorType error struct property."
    return self._error

  @error.setter
  def error(self, value):
    self._error = msgbuffers.validate_integer(
      'IntentError.error', value, 0, 255)

  @property
  def extra(self):
    "string[uint_8] extra struct property."
    return self._extra

  @extra.setter
  def extra(self, value):
    self._extra = msgbuffers.validate_string(
      'IntentError.extra', value, 255)

  def __init__(self, error=Anki.Vector.CloudMic.ErrorType.Server, extra=''):
    self.error = error
    self.extra = extra

  @classmethod
  def unpack(cls, buffer):
    "Reads a new IntentError from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('IntentError.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new IntentError from the given BinaryReader."
    _error = reader.read('B')
    _extra = reader.read_string('B')
    return cls(_error, _extra)

  def pack(self):
    "Writes the current IntentError, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current IntentError to the given BinaryWriter."
    writer.write(self._error, 'B')
    writer.write_string(self._extra, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._error == other._error and
        self._extra == other._extra)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._error, 'B') +
      msgbuffers.size_string(self._extra, 'B'))

  def __str__(self):
    return '{type}(error={error}, extra={extra})'.format(
      type=type(self).__name__,
      error=self._error,
      extra=msgbuffers.shorten_string(self._extra))

  def __repr__(self):
    return '{type}(error={error}, extra={extra})'.format(
      type=type(self).__name__,
      error=repr(self._error),
      extra=repr(self._extra))

Anki.Vector.CloudMic.IntentError = IntentError
del IntentError


class ConnectionResult(object):
  "Generated message-passing structure."

  __slots__ = (
    '_code',            # Anki.Vector.CloudMic.ConnectionCode
    '_status',          # string[uint_8]
    '_numPackets',      # uint_8
    '_expectedPackets', # uint_8
  )

  @property
  def code(self):
    "Anki.Vector.CloudMic.ConnectionCode code struct property."
    return self._code

  @code.setter
  def code(self, value):
    self._code = msgbuffers.validate_integer(
      'ConnectionResult.code', value, 0, 255)

  @property
  def status(self):
    "string[uint_8] status struct property."
    return self._status

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_string(
      'ConnectionResult.status', value, 255)

  @property
  def numPackets(self):
    "uint_8 numPackets struct property."
    return self._numPackets

  @numPackets.setter
  def numPackets(self, value):
    self._numPackets = msgbuffers.validate_integer(
      'ConnectionResult.numPackets', value, 0, 255)

  @property
  def expectedPackets(self):
    "uint_8 expectedPackets struct property."
    return self._expectedPackets

  @expectedPackets.setter
  def expectedPackets(self, value):
    self._expectedPackets = msgbuffers.validate_integer(
      'ConnectionResult.expectedPackets', value, 0, 255)

  def __init__(self, code=Anki.Vector.CloudMic.ConnectionCode.Available, status='', numPackets=0, expectedPackets=0):
    self.code = code
    self.status = status
    self.numPackets = numPackets
    self.expectedPackets = expectedPackets

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ConnectionResult from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ConnectionResult.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ConnectionResult from the given BinaryReader."
    _code = reader.read('B')
    _status = reader.read_string('B')
    _numPackets = reader.read('B')
    _expectedPackets = reader.read('B')
    return cls(_code, _status, _numPackets, _expectedPackets)

  def pack(self):
    "Writes the current ConnectionResult, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ConnectionResult to the given BinaryWriter."
    writer.write(self._code, 'B')
    writer.write_string(self._status, 'B')
    writer.write(self._numPackets, 'B')
    writer.write(self._expectedPackets, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._code == other._code and
        self._status == other._status and
        self._numPackets == other._numPackets and
        self._expectedPackets == other._expectedPackets)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._code, 'B') +
      msgbuffers.size_string(self._status, 'B') +
      msgbuffers.size(self._numPackets, 'B') +
      msgbuffers.size(self._expectedPackets, 'B'))

  def __str__(self):
    return '{type}(code={code}, status={status}, numPackets={numPackets}, expectedPackets={expectedPackets})'.format(
      type=type(self).__name__,
      code=self._code,
      status=msgbuffers.shorten_string(self._status),
      numPackets=self._numPackets,
      expectedPackets=self._expectedPackets)

  def __repr__(self):
    return '{type}(code={code}, status={status}, numPackets={numPackets}, expectedPackets={expectedPackets})'.format(
      type=type(self).__name__,
      code=repr(self._code),
      status=repr(self._status),
      numPackets=repr(self._numPackets),
      expectedPackets=repr(self._expectedPackets))

Anki.Vector.CloudMic.ConnectionResult = ConnectionResult
del ConnectionResult


class Message(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    hotword          = 0  # Anki.Vector.CloudMic.Hotword
    audio            = 1  # Anki.Vector.CloudMic.AudioData
    audioDone        = 2  # Anki.Vector.Void
    connectionCheck  = 3  # Anki.Vector.Void
    stopSignal       = 4  # Anki.Vector.Void
    testStarted      = 5  # Anki.Vector.Void
    streamTimeout    = 6  # Anki.Vector.Void
    connectionResult = 7  # Anki.Vector.CloudMic.ConnectionResult
    debugFile        = 8  # Anki.Vector.CloudMic.Filename
    result           = 9  # Anki.Vector.CloudMic.IntentResult
    error            = 10 # Anki.Vector.CloudMic.IntentError
    streamOpen       = 11 # Anki.Vector.CloudMic.StreamOpen

  @property
  def tag(self):
    "The current tag for this union."
    return self._tag

  @property
  def tag_name(self):
    "The name of the current tag for this union."
    if self._tag in self._tags_by_value:
      return self._tags_by_value[self._tag]
    else:
      return None

  @property
  def data(self):
    "The data held by this union. None if no data is set."
    return self._data

  @property
  def hotword(self):
    "Anki.Vector.CloudMic.Hotword hotword union property."
    msgbuffers.safety_check_tag('hotword', self._tag, self.Tag.hotword, self._tags_by_value)
    return self._data

  @hotword.setter
  def hotword(self, value):
    self._data = msgbuffers.validate_object(
      'Message.hotword', value, Anki.Vector.CloudMic.Hotword)
    self._tag = self.Tag.hotword

  @property
  def audio(self):
    "Anki.Vector.CloudMic.AudioData audio union property."
    msgbuffers.safety_check_tag('audio', self._tag, self.Tag.audio, self._tags_by_value)
    return self._data

  @audio.setter
  def audio(self, value):
    self._data = msgbuffers.validate_object(
      'Message.audio', value, Anki.Vector.CloudMic.AudioData)
    self._tag = self.Tag.audio

  @property
  def audioDone(self):
    "Anki.Vector.Void audioDone union property."
    msgbuffers.safety_check_tag('audioDone', self._tag, self.Tag.audioDone, self._tags_by_value)
    return self._data

  @audioDone.setter
  def audioDone(self, value):
    self._data = msgbuffers.validate_object(
      'Message.audioDone', value, Anki.Vector.Void)
    self._tag = self.Tag.audioDone

  @property
  def connectionCheck(self):
    "Anki.Vector.Void connectionCheck union property."
    msgbuffers.safety_check_tag('connectionCheck', self._tag, self.Tag.connectionCheck, self._tags_by_value)
    return self._data

  @connectionCheck.setter
  def connectionCheck(self, value):
    self._data = msgbuffers.validate_object(
      'Message.connectionCheck', value, Anki.Vector.Void)
    self._tag = self.Tag.connectionCheck

  @property
  def stopSignal(self):
    "Anki.Vector.Void stopSignal union property."
    msgbuffers.safety_check_tag('stopSignal', self._tag, self.Tag.stopSignal, self._tags_by_value)
    return self._data

  @stopSignal.setter
  def stopSignal(self, value):
    self._data = msgbuffers.validate_object(
      'Message.stopSignal', value, Anki.Vector.Void)
    self._tag = self.Tag.stopSignal

  @property
  def testStarted(self):
    "Anki.Vector.Void testStarted union property."
    msgbuffers.safety_check_tag('testStarted', self._tag, self.Tag.testStarted, self._tags_by_value)
    return self._data

  @testStarted.setter
  def testStarted(self, value):
    self._data = msgbuffers.validate_object(
      'Message.testStarted', value, Anki.Vector.Void)
    self._tag = self.Tag.testStarted

  @property
  def streamTimeout(self):
    "Anki.Vector.Void streamTimeout union property."
    msgbuffers.safety_check_tag('streamTimeout', self._tag, self.Tag.streamTimeout, self._tags_by_value)
    return self._data

  @streamTimeout.setter
  def streamTimeout(self, value):
    self._data = msgbuffers.validate_object(
      'Message.streamTimeout', value, Anki.Vector.Void)
    self._tag = self.Tag.streamTimeout

  @property
  def connectionResult(self):
    "Anki.Vector.CloudMic.ConnectionResult connectionResult union property."
    msgbuffers.safety_check_tag('connectionResult', self._tag, self.Tag.connectionResult, self._tags_by_value)
    return self._data

  @connectionResult.setter
  def connectionResult(self, value):
    self._data = msgbuffers.validate_object(
      'Message.connectionResult', value, Anki.Vector.CloudMic.ConnectionResult)
    self._tag = self.Tag.connectionResult

  @property
  def debugFile(self):
    "Anki.Vector.CloudMic.Filename debugFile union property."
    msgbuffers.safety_check_tag('debugFile', self._tag, self.Tag.debugFile, self._tags_by_value)
    return self._data

  @debugFile.setter
  def debugFile(self, value):
    self._data = msgbuffers.validate_object(
      'Message.debugFile', value, Anki.Vector.CloudMic.Filename)
    self._tag = self.Tag.debugFile

  @property
  def result(self):
    "Anki.Vector.CloudMic.IntentResult result union property."
    msgbuffers.safety_check_tag('result', self._tag, self.Tag.result, self._tags_by_value)
    return self._data

  @result.setter
  def result(self, value):
    self._data = msgbuffers.validate_object(
      'Message.result', value, Anki.Vector.CloudMic.IntentResult)
    self._tag = self.Tag.result

  @property
  def error(self):
    "Anki.Vector.CloudMic.IntentError error union property."
    msgbuffers.safety_check_tag('error', self._tag, self.Tag.error, self._tags_by_value)
    return self._data

  @error.setter
  def error(self, value):
    self._data = msgbuffers.validate_object(
      'Message.error', value, Anki.Vector.CloudMic.IntentError)
    self._tag = self.Tag.error

  @property
  def streamOpen(self):
    "Anki.Vector.CloudMic.StreamOpen streamOpen union property."
    msgbuffers.safety_check_tag('streamOpen', self._tag, self.Tag.streamOpen, self._tags_by_value)
    return self._data

  @streamOpen.setter
  def streamOpen(self, value):
    self._data = msgbuffers.validate_object(
      'Message.streamOpen', value, Anki.Vector.CloudMic.StreamOpen)
    self._tag = self.Tag.streamOpen

  def __init__(self, **kwargs):
    if not kwargs:
      self._tag = None
      self._data = None

    elif len(kwargs) == 1:
      key, value = next(iter(kwargs.items()))
      if key not in self._tags_by_name:
        raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key))
      # calls the correct property
      setattr(self, key, value)

    else:
      raise TypeError('This method only accepts up to one keyword argument.')

  @classmethod
  def unpack(cls, buffer):
    "Reads a new Message from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('Message.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new Message from the given BinaryReader."
    tag = reader.read('B')
    if tag in cls._tags_by_value:
      value = cls()
      setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader))
      return value
    else:
      raise ValueError('Message attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current Message, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current SampleUnion to the given BinaryWriter."
    if self._tag in self._tags_by_value:
      writer.write(self._tag, 'B')
      self._tag_pack_methods[self._tag](writer, self._data)
    else:
      raise ValueError('Cannot pack an empty Message.')

  def clear(self):
    self._tag = None
    self._data = None

  @classmethod
  def typeByTag(cls, tag):
    return cls._type_by_tag_value[tag]()

  def __eq__(self, other):
    if type(self) is type(other):
      return self._tag == other._tag and self._data == other._data
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    if 0 <= self._tag < 12:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 12:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=self._data)
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  def __repr__(self):
    if 0 <= self._tag < 12:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=repr(self._data))
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  _tags_by_name = dict(
    hotword=0,
    audio=1,
    audioDone=2,
    connectionCheck=3,
    stopSignal=4,
    testStarted=5,
    streamTimeout=6,
    connectionResult=7,
    debugFile=8,
    result=9,
    error=10,
    streamOpen=11,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'hotword'
  _tags_by_value[1] = 'audio'
  _tags_by_value[2] = 'audioDone'
  _tags_by_value[3] = 'connectionCheck'
  _tags_by_value[4] = 'stopSignal'
  _tags_by_value[5] = 'testStarted'
  _tags_by_value[6] = 'streamTimeout'
  _tags_by_value[7] = 'connectionResult'
  _tags_by_value[8] = 'debugFile'
  _tags_by_value[9] = 'result'
  _tags_by_value[10] = 'error'
  _tags_by_value[11] = 'streamOpen'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.CloudMic.Hotword.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.CloudMic.AudioData.unpack_from)
  _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[3] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[4] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[5] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[6] = lambda reader: reader.read_object(Anki.Vector.Void.unpack_from)
  _tag_unpack_methods[7] = lambda reader: reader.read_object(Anki.Vector.CloudMic.ConnectionResult.unpack_from)
  _tag_unpack_methods[8] = lambda reader: reader.read_object(Anki.Vector.CloudMic.Filename.unpack_from)
  _tag_unpack_methods[9] = lambda reader: reader.read_object(Anki.Vector.CloudMic.IntentResult.unpack_from)
  _tag_unpack_methods[10] = lambda reader: reader.read_object(Anki.Vector.CloudMic.IntentError.unpack_from)
  _tag_unpack_methods[11] = lambda reader: reader.read_object(Anki.Vector.CloudMic.StreamOpen.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[0] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[1] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[2] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[3] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[4] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[5] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[6] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[7] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[8] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[9] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[10] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[11] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[2] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[3] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[4] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[5] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[6] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[7] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[8] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[9] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[10] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[11] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.CloudMic.Hotword
  _type_by_tag_value[1] = lambda : Anki.Vector.CloudMic.AudioData
  _type_by_tag_value[2] = lambda : Anki.Vector.Void
  _type_by_tag_value[3] = lambda : Anki.Vector.Void
  _type_by_tag_value[4] = lambda : Anki.Vector.Void
  _type_by_tag_value[5] = lambda : Anki.Vector.Void
  _type_by_tag_value[6] = lambda : Anki.Vector.Void
  _type_by_tag_value[7] = lambda : Anki.Vector.CloudMic.ConnectionResult
  _type_by_tag_value[8] = lambda : Anki.Vector.CloudMic.Filename
  _type_by_tag_value[9] = lambda : Anki.Vector.CloudMic.IntentResult
  _type_by_tag_value[10] = lambda : Anki.Vector.CloudMic.IntentError
  _type_by_tag_value[11] = lambda : Anki.Vector.CloudMic.StreamOpen
  

Anki.Vector.CloudMic.Message = Message
del Message