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

package gateway

import (
  "bytes"
  "encoding/binary"
  "errors"
  "anki/clad"
  "fmt"
)

import . "clad/cloud"
// MESSAGE SwitchboardError
type SwitchboardError struct {
}

func (s *SwitchboardError) Size() uint32 {
  return 0
}

func (s *SwitchboardError) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (s *SwitchboardError) Pack(buf *bytes.Buffer) error {
  return nil
}

func (s *SwitchboardError) String() string {
  return ""
}


// MESSAGE ExternalConnectionRequest
type ExternalConnectionRequest struct {
}

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

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

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

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


// MESSAGE ExternalConnectionResponse
type ExternalConnectionResponse struct {
  IsConnected bool
  ConnectionId string
}

func (e *ExternalConnectionResponse) Size() uint32 {
  var result uint32
  result += 1 // IsConnected bool
  result += 2 // ConnectionId length (uint_16)
  result += uint32(len(e.ConnectionId)) // uint_8 array
  return result
}

func (e *ExternalConnectionResponse) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &e.IsConnected); err != nil {
    return err
  }
  var ConnectionIdLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &ConnectionIdLen); err != nil {
    return err
  }
  e.ConnectionId = string(buf.Next(int(ConnectionIdLen)))
  if len(e.ConnectionId) != int(ConnectionIdLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (e *ExternalConnectionResponse) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, e.IsConnected); err != nil {
    return err
  }
  if len(e.ConnectionId) > 65535 {
    return errors.New("max_length overflow in field ConnectionId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(e.ConnectionId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(e.ConnectionId); err != nil {
    return err
  }
  return nil
}

func (e *ExternalConnectionResponse) String() string {
  return fmt.Sprint("IsConnected: {", e.IsConnected, "} ",
    "ConnectionId: {", e.ConnectionId, "}")
}


// MESSAGE ClientGuidRefreshRequest
type ClientGuidRefreshRequest struct {
}

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

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

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

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


// MESSAGE ClientGuidRefreshResponse
type ClientGuidRefreshResponse struct {
}

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

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

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

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


// MESSAGE SdkProxyRequest
type SdkProxyRequest struct {
  ClientGuid string
  MessageId string
  Path string
  Json string
}

func (s *SdkProxyRequest) Size() uint32 {
  var result uint32
  result += 1 // ClientGuid length (uint_8)
  result += uint32(len(s.ClientGuid)) // uint_8 array
  result += 1 // MessageId length (uint_8)
  result += uint32(len(s.MessageId)) // uint_8 array
  result += 1 // Path length (uint_8)
  result += uint32(len(s.Path)) // uint_8 array
  result += 2 // Json length (uint_16)
  result += uint32(len(s.Json)) // uint_8 array
  return result
}

func (s *SdkProxyRequest) Unpack(buf *bytes.Buffer) error {
  var ClientGuidLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ClientGuidLen); err != nil {
    return err
  }
  s.ClientGuid = string(buf.Next(int(ClientGuidLen)))
  if len(s.ClientGuid) != int(ClientGuidLen) {
    return errors.New("string byte mismatch")
  }
  var MessageIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &MessageIdLen); err != nil {
    return err
  }
  s.MessageId = string(buf.Next(int(MessageIdLen)))
  if len(s.MessageId) != int(MessageIdLen) {
    return errors.New("string byte mismatch")
  }
  var PathLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &PathLen); err != nil {
    return err
  }
  s.Path = string(buf.Next(int(PathLen)))
  if len(s.Path) != int(PathLen) {
    return errors.New("string byte mismatch")
  }
  var JsonLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &JsonLen); err != nil {
    return err
  }
  s.Json = string(buf.Next(int(JsonLen)))
  if len(s.Json) != int(JsonLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (s *SdkProxyRequest) Pack(buf *bytes.Buffer) error {
  if len(s.ClientGuid) > 255 {
    return errors.New("max_length overflow in field ClientGuid")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.ClientGuid))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.ClientGuid); err != nil {
    return err
  }
  if len(s.MessageId) > 255 {
    return errors.New("max_length overflow in field MessageId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.MessageId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.MessageId); err != nil {
    return err
  }
  if len(s.Path) > 255 {
    return errors.New("max_length overflow in field Path")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.Path))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.Path); err != nil {
    return err
  }
  if len(s.Json) > 65535 {
    return errors.New("max_length overflow in field Json")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(s.Json))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.Json); err != nil {
    return err
  }
  return nil
}

func (s *SdkProxyRequest) String() string {
  return fmt.Sprint("ClientGuid: {", s.ClientGuid, "} ",
    "MessageId: {", s.MessageId, "} ",
    "Path: {", s.Path, "} ",
    "Json: {", s.Json, "}")
}


// MESSAGE SdkProxyResponse
type SdkProxyResponse struct {
  MessageId string
  StatusCode uint16
  ContentType string
  Content string
}

func (s *SdkProxyResponse) Size() uint32 {
  var result uint32
  result += 1 // MessageId length (uint_8)
  result += uint32(len(s.MessageId)) // uint_8 array
  result += 2 // StatusCode uint_16
  result += 1 // ContentType length (uint_8)
  result += uint32(len(s.ContentType)) // uint_8 array
  result += 2 // Content length (uint_16)
  result += uint32(len(s.Content)) // uint_8 array
  return result
}

func (s *SdkProxyResponse) Unpack(buf *bytes.Buffer) error {
  var MessageIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &MessageIdLen); err != nil {
    return err
  }
  s.MessageId = string(buf.Next(int(MessageIdLen)))
  if len(s.MessageId) != int(MessageIdLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.StatusCode); err != nil {
    return err
  }
  var ContentTypeLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ContentTypeLen); err != nil {
    return err
  }
  s.ContentType = string(buf.Next(int(ContentTypeLen)))
  if len(s.ContentType) != int(ContentTypeLen) {
    return errors.New("string byte mismatch")
  }
  var ContentLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &ContentLen); err != nil {
    return err
  }
  s.Content = string(buf.Next(int(ContentLen)))
  if len(s.Content) != int(ContentLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (s *SdkProxyResponse) Pack(buf *bytes.Buffer) error {
  if len(s.MessageId) > 255 {
    return errors.New("max_length overflow in field MessageId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.MessageId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.MessageId); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.StatusCode); err != nil {
    return err
  }
  if len(s.ContentType) > 255 {
    return errors.New("max_length overflow in field ContentType")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.ContentType))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.ContentType); err != nil {
    return err
  }
  if len(s.Content) > 65535 {
    return errors.New("max_length overflow in field Content")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(s.Content))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.Content); err != nil {
    return err
  }
  return nil
}

func (s *SdkProxyResponse) String() string {
  return fmt.Sprint("MessageId: {", s.MessageId, "} ",
    "StatusCode: {", s.StatusCode, "} ",
    "ContentType: {", s.ContentType, "} ",
    "Content: {", s.Content, "}")
}


// UNION SwitchboardRequest
type SwitchboardRequestTag uint8

const (
  SwitchboardRequestTag_SwitchboardError           SwitchboardRequestTag = 0x1 // 1
  SwitchboardRequestTag_AuthRequest                SwitchboardRequestTag = 0x2 // 2
  SwitchboardRequestTag_JwtRequest                 SwitchboardRequestTag = 0x3 // 3
  SwitchboardRequestTag_ExternalConnectionRequest  SwitchboardRequestTag = 0x4 // 4
  SwitchboardRequestTag_ExternalConnectionResponse SwitchboardRequestTag = 0x5 // 5
  SwitchboardRequestTag_ClientGuidRefreshResponse  SwitchboardRequestTag = 0x6 // 6
  SwitchboardRequestTag_SdkProxyResponse           SwitchboardRequestTag = 0x7 // 7
  SwitchboardRequestTag_INVALID                    SwitchboardRequestTag = 255
)

type SwitchboardRequest struct {
  tag *SwitchboardRequestTag
  value clad.Struct
}

func (m *SwitchboardRequest) Tag() SwitchboardRequestTag {
  if m.tag == nil {
    return SwitchboardRequestTag_INVALID
  }
  return *m.tag
}

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

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

func (m *SwitchboardRequest) unpackStruct(tag SwitchboardRequestTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case SwitchboardRequestTag_SwitchboardError:
    var ret SwitchboardError
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_AuthRequest:
    var ret AuthRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_JwtRequest:
    var ret JwtRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_ExternalConnectionRequest:
    var ret ExternalConnectionRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_ExternalConnectionResponse:
    var ret ExternalConnectionResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_ClientGuidRefreshResponse:
    var ret ClientGuidRefreshResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardRequestTag_SdkProxyResponse:
    var ret SdkProxyResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

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

func (t SwitchboardRequestTag) String() string {
  switch t {
  case SwitchboardRequestTag_SwitchboardError:
    return "SwitchboardError"
  case SwitchboardRequestTag_AuthRequest:
    return "AuthRequest"
  case SwitchboardRequestTag_JwtRequest:
    return "JwtRequest"
  case SwitchboardRequestTag_ExternalConnectionRequest:
    return "ExternalConnectionRequest"
  case SwitchboardRequestTag_ExternalConnectionResponse:
    return "ExternalConnectionResponse"
  case SwitchboardRequestTag_ClientGuidRefreshResponse:
    return "ClientGuidRefreshResponse"
  case SwitchboardRequestTag_SdkProxyResponse:
    return "SdkProxyResponse"
  default:
    return "INVALID"
  }
}

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

func (m *SwitchboardRequest) GetSwitchboardError() *SwitchboardError {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_SwitchboardError {
    return nil
  }
  return m.value.(*SwitchboardError)
}

func (m *SwitchboardRequest) SetSwitchboardError(value *SwitchboardError) {
  newTag := SwitchboardRequestTag_SwitchboardError
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithSwitchboardError(value *SwitchboardError) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetSwitchboardError(value)
  return &ret
}

func (m *SwitchboardRequest) GetAuthRequest() *AuthRequest {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_AuthRequest {
    return nil
  }
  return m.value.(*AuthRequest)
}

func (m *SwitchboardRequest) SetAuthRequest(value *AuthRequest) {
  newTag := SwitchboardRequestTag_AuthRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithAuthRequest(value *AuthRequest) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetAuthRequest(value)
  return &ret
}

func (m *SwitchboardRequest) GetJwtRequest() *JwtRequest {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_JwtRequest {
    return nil
  }
  return m.value.(*JwtRequest)
}

func (m *SwitchboardRequest) SetJwtRequest(value *JwtRequest) {
  newTag := SwitchboardRequestTag_JwtRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithJwtRequest(value *JwtRequest) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetJwtRequest(value)
  return &ret
}

func (m *SwitchboardRequest) GetExternalConnectionRequest() *ExternalConnectionRequest {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_ExternalConnectionRequest {
    return nil
  }
  return m.value.(*ExternalConnectionRequest)
}

func (m *SwitchboardRequest) SetExternalConnectionRequest(value *ExternalConnectionRequest) {
  newTag := SwitchboardRequestTag_ExternalConnectionRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithExternalConnectionRequest(value *ExternalConnectionRequest) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetExternalConnectionRequest(value)
  return &ret
}

func (m *SwitchboardRequest) GetExternalConnectionResponse() *ExternalConnectionResponse {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_ExternalConnectionResponse {
    return nil
  }
  return m.value.(*ExternalConnectionResponse)
}

func (m *SwitchboardRequest) SetExternalConnectionResponse(value *ExternalConnectionResponse) {
  newTag := SwitchboardRequestTag_ExternalConnectionResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithExternalConnectionResponse(value *ExternalConnectionResponse) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetExternalConnectionResponse(value)
  return &ret
}

func (m *SwitchboardRequest) GetClientGuidRefreshResponse() *ClientGuidRefreshResponse {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_ClientGuidRefreshResponse {
    return nil
  }
  return m.value.(*ClientGuidRefreshResponse)
}

func (m *SwitchboardRequest) SetClientGuidRefreshResponse(value *ClientGuidRefreshResponse) {
  newTag := SwitchboardRequestTag_ClientGuidRefreshResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithClientGuidRefreshResponse(value *ClientGuidRefreshResponse) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetClientGuidRefreshResponse(value)
  return &ret
}

func (m *SwitchboardRequest) GetSdkProxyResponse() *SdkProxyResponse {
  if m.tag == nil || *m.tag != SwitchboardRequestTag_SdkProxyResponse {
    return nil
  }
  return m.value.(*SdkProxyResponse)
}

func (m *SwitchboardRequest) SetSdkProxyResponse(value *SdkProxyResponse) {
  newTag := SwitchboardRequestTag_SdkProxyResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardRequestWithSdkProxyResponse(value *SdkProxyResponse) *SwitchboardRequest {
  var ret SwitchboardRequest
  ret.SetSdkProxyResponse(value)
  return &ret
}


// UNION SwitchboardResponse
type SwitchboardResponseTag uint8

const (
  SwitchboardResponseTag_SwitchboardError           SwitchboardResponseTag = 0x1 // 1
  SwitchboardResponseTag_AuthResponse               SwitchboardResponseTag = 0x2 // 2
  SwitchboardResponseTag_JwtResponse                SwitchboardResponseTag = 0x3 // 3
  SwitchboardResponseTag_ExternalConnectionRequest  SwitchboardResponseTag = 0x4 // 4
  SwitchboardResponseTag_ExternalConnectionResponse SwitchboardResponseTag = 0x5 // 5
  SwitchboardResponseTag_ClientGuidRefreshRequest   SwitchboardResponseTag = 0x6 // 6
  SwitchboardResponseTag_SdkProxyRequest            SwitchboardResponseTag = 0x7 // 7
  SwitchboardResponseTag_INVALID                    SwitchboardResponseTag = 255
)

type SwitchboardResponse struct {
  tag *SwitchboardResponseTag
  value clad.Struct
}

func (m *SwitchboardResponse) Tag() SwitchboardResponseTag {
  if m.tag == nil {
    return SwitchboardResponseTag_INVALID
  }
  return *m.tag
}

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

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

func (m *SwitchboardResponse) unpackStruct(tag SwitchboardResponseTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case SwitchboardResponseTag_SwitchboardError:
    var ret SwitchboardError
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_AuthResponse:
    var ret AuthResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_JwtResponse:
    var ret JwtResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_ExternalConnectionRequest:
    var ret ExternalConnectionRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_ExternalConnectionResponse:
    var ret ExternalConnectionResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_ClientGuidRefreshRequest:
    var ret ClientGuidRefreshRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case SwitchboardResponseTag_SdkProxyRequest:
    var ret SdkProxyRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

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

func (t SwitchboardResponseTag) String() string {
  switch t {
  case SwitchboardResponseTag_SwitchboardError:
    return "SwitchboardError"
  case SwitchboardResponseTag_AuthResponse:
    return "AuthResponse"
  case SwitchboardResponseTag_JwtResponse:
    return "JwtResponse"
  case SwitchboardResponseTag_ExternalConnectionRequest:
    return "ExternalConnectionRequest"
  case SwitchboardResponseTag_ExternalConnectionResponse:
    return "ExternalConnectionResponse"
  case SwitchboardResponseTag_ClientGuidRefreshRequest:
    return "ClientGuidRefreshRequest"
  case SwitchboardResponseTag_SdkProxyRequest:
    return "SdkProxyRequest"
  default:
    return "INVALID"
  }
}

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

func (m *SwitchboardResponse) GetSwitchboardError() *SwitchboardError {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_SwitchboardError {
    return nil
  }
  return m.value.(*SwitchboardError)
}

func (m *SwitchboardResponse) SetSwitchboardError(value *SwitchboardError) {
  newTag := SwitchboardResponseTag_SwitchboardError
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithSwitchboardError(value *SwitchboardError) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetSwitchboardError(value)
  return &ret
}

func (m *SwitchboardResponse) GetAuthResponse() *AuthResponse {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_AuthResponse {
    return nil
  }
  return m.value.(*AuthResponse)
}

func (m *SwitchboardResponse) SetAuthResponse(value *AuthResponse) {
  newTag := SwitchboardResponseTag_AuthResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithAuthResponse(value *AuthResponse) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetAuthResponse(value)
  return &ret
}

func (m *SwitchboardResponse) GetJwtResponse() *JwtResponse {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_JwtResponse {
    return nil
  }
  return m.value.(*JwtResponse)
}

func (m *SwitchboardResponse) SetJwtResponse(value *JwtResponse) {
  newTag := SwitchboardResponseTag_JwtResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithJwtResponse(value *JwtResponse) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetJwtResponse(value)
  return &ret
}

func (m *SwitchboardResponse) GetExternalConnectionRequest() *ExternalConnectionRequest {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_ExternalConnectionRequest {
    return nil
  }
  return m.value.(*ExternalConnectionRequest)
}

func (m *SwitchboardResponse) SetExternalConnectionRequest(value *ExternalConnectionRequest) {
  newTag := SwitchboardResponseTag_ExternalConnectionRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithExternalConnectionRequest(value *ExternalConnectionRequest) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetExternalConnectionRequest(value)
  return &ret
}

func (m *SwitchboardResponse) GetExternalConnectionResponse() *ExternalConnectionResponse {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_ExternalConnectionResponse {
    return nil
  }
  return m.value.(*ExternalConnectionResponse)
}

func (m *SwitchboardResponse) SetExternalConnectionResponse(value *ExternalConnectionResponse) {
  newTag := SwitchboardResponseTag_ExternalConnectionResponse
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithExternalConnectionResponse(value *ExternalConnectionResponse) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetExternalConnectionResponse(value)
  return &ret
}

func (m *SwitchboardResponse) GetClientGuidRefreshRequest() *ClientGuidRefreshRequest {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_ClientGuidRefreshRequest {
    return nil
  }
  return m.value.(*ClientGuidRefreshRequest)
}

func (m *SwitchboardResponse) SetClientGuidRefreshRequest(value *ClientGuidRefreshRequest) {
  newTag := SwitchboardResponseTag_ClientGuidRefreshRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithClientGuidRefreshRequest(value *ClientGuidRefreshRequest) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetClientGuidRefreshRequest(value)
  return &ret
}

func (m *SwitchboardResponse) GetSdkProxyRequest() *SdkProxyRequest {
  if m.tag == nil || *m.tag != SwitchboardResponseTag_SdkProxyRequest {
    return nil
  }
  return m.value.(*SdkProxyRequest)
}

func (m *SwitchboardResponse) SetSdkProxyRequest(value *SdkProxyRequest) {
  newTag := SwitchboardResponseTag_SdkProxyRequest
  m.tag = &newTag
  m.value = value
}

func NewSwitchboardResponseWithSdkProxyRequest(value *SdkProxyRequest) *SwitchboardResponse {
  var ret SwitchboardResponse
  ret.SetSdkProxyRequest(value)
  return &ret
}