// 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"
	"fmt"

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

	. "github.com/digital-dream-labs/vector-cloud/internal/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
}