webrtc.pb.go

// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.6.5
// source: github.com/aperturerobotics/bifrost/transport/webrtc/webrtc.proto

package webrtc

import (
	fmt "fmt"
	io "io"
	strconv "strconv"
	strings "strings"

	_ "github.com/aperturerobotics/bifrost/stream/srpc/client"
	dialer "github.com/aperturerobotics/bifrost/transport/common/dialer"
	quic "github.com/aperturerobotics/bifrost/transport/common/quic"
	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	json "github.com/aperturerobotics/protobuf-go-lite/json"
	backoff "github.com/aperturerobotics/util/backoff"
)

// IceTransportPolicy contains the set of allowed ICE transport policies.
type IceTransportPolicy int32

const (
	// IceTransportPolicy_ALL allows any kind of ICE candidate.
	IceTransportPolicy_IceTransportPolicy_ALL IceTransportPolicy = 0
	// IceTransportPolicy_RELAY allows only media relay candidates (TURN).
	IceTransportPolicy_IceTransportPolicy_RELAY IceTransportPolicy = 1
)

// Enum value maps for IceTransportPolicy.
var (
	IceTransportPolicy_name = map[int32]string{
		0: "IceTransportPolicy_ALL",
		1: "IceTransportPolicy_RELAY",
	}
	IceTransportPolicy_value = map[string]int32{
		"IceTransportPolicy_ALL":   0,
		"IceTransportPolicy_RELAY": 1,
	}
)

func (x IceTransportPolicy) Enum() *IceTransportPolicy {
	p := new(IceTransportPolicy)
	*p = x
	return p
}

func (x IceTransportPolicy) String() string {
	name, valid := IceTransportPolicy_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

// Config is the configuration for the WebRTC Signal RPC transport.
type Config struct {
	unknownFields []byte
	// SignalingId is the signaling channel identifier.
	// Cannot be empty.
	SignalingId string `protobuf:"bytes,1,opt,name=signaling_id,json=signalingId,proto3" json:"signalingId,omitempty"`
	// TransportPeerId sets the peer ID to attach the transport to.
	// If unset, attaches to any running peer with a private key.
	// Must match the transport peer ID of the signaling transport.
	TransportPeerId string `protobuf:"bytes,2,opt,name=transport_peer_id,json=transportPeerId,proto3" json:"transportPeerId,omitempty"`
	// TransportType overrides the transport type id for dial addresses.
	// Defaults to "webrtc"
	// Configures the scheme for addr matching to this transport.
	// E.x.: webrtc://
	TransportType string `protobuf:"bytes,3,opt,name=transport_type,json=transportType,proto3" json:"transportType,omitempty"`
	// Quic contains the quic protocol options.
	//
	// The WebRTC transport always disables FEC and several other UDP-centric
	// features which are unnecessary due to the "reliable" nature of WebRTC.
	Quic *quic.Opts `protobuf:"bytes,4,opt,name=quic,proto3" json:"quic,omitempty"`
	// WebRtc contains the WebRTC protocol options.
	WebRtc *WebRtcConfig `protobuf:"bytes,5,opt,name=web_rtc,json=webRtc,proto3" json:"webRtc,omitempty"`
	// Backoff is the backoff config for connecting to a PeerConnection.
	// If unset, defaults to reasonable defaults.
	Backoff *backoff.Backoff `protobuf:"bytes,6,opt,name=backoff,proto3" json:"backoff,omitempty"`
	// Dialers maps peer IDs to dialers.
	// This allows mapping which peer ID should be dialed via this transport.
	Dialers map[string]*dialer.DialerOpts `protobuf:"bytes,7,rep,name=dialers,proto3" json:"dialers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// AllPeers tells the transport to attempt to negotiate a WebRTC session with
	// any peer, even those not listed in the Dialers map.
	AllPeers bool `protobuf:"varint,8,opt,name=all_peers,json=allPeers,proto3" json:"allPeers,omitempty"`
	// DisableListen disables listening for incoming Links.
	// If set, we will only dial out, not accept incoming links.
	DisableListen bool `protobuf:"varint,9,opt,name=disable_listen,json=disableListen,proto3" json:"disableListen,omitempty"`
	// BlockPeers is a list of peer ids that will not be contacted via this transport.
	BlockPeers []string `protobuf:"bytes,10,rep,name=block_peers,json=blockPeers,proto3" json:"blockPeers,omitempty"`
	// Verbose enables very verbose logging.
	Verbose bool `protobuf:"varint,11,opt,name=verbose,proto3" json:"verbose,omitempty"`
}

func (x *Config) Reset() {
	*x = Config{}
}

func (*Config) ProtoMessage() {}

func (x *Config) GetSignalingId() string {
	if x != nil {
		return x.SignalingId
	}
	return ""
}

func (x *Config) GetTransportPeerId() string {
	if x != nil {
		return x.TransportPeerId
	}
	return ""
}

func (x *Config) GetTransportType() string {
	if x != nil {
		return x.TransportType
	}
	return ""
}

func (x *Config) GetQuic() *quic.Opts {
	if x != nil {
		return x.Quic
	}
	return nil
}

func (x *Config) GetWebRtc() *WebRtcConfig {
	if x != nil {
		return x.WebRtc
	}
	return nil
}

func (x *Config) GetBackoff() *backoff.Backoff {
	if x != nil {
		return x.Backoff
	}
	return nil
}

func (x *Config) GetDialers() map[string]*dialer.DialerOpts {
	if x != nil {
		return x.Dialers
	}
	return nil
}

func (x *Config) GetAllPeers() bool {
	if x != nil {
		return x.AllPeers
	}
	return false
}

func (x *Config) GetDisableListen() bool {
	if x != nil {
		return x.DisableListen
	}
	return false
}

func (x *Config) GetBlockPeers() []string {
	if x != nil {
		return x.BlockPeers
	}
	return nil
}

func (x *Config) GetVerbose() bool {
	if x != nil {
		return x.Verbose
	}
	return false
}

// WebRtcConfig configures the WebRTC PeerConnection.
type WebRtcConfig struct {
	unknownFields []byte
	// IceServers contains the list of ICE servers to use.
	IceServers []*IceServerConfig `protobuf:"bytes,1,rep,name=ice_servers,json=iceServers,proto3" json:"iceServers,omitempty"`
	// IceTransportPolicy defines the policy for permitted ICE candidates.
	// Optional.
	IceTransportPolicy IceTransportPolicy `protobuf:"varint,2,opt,name=ice_transport_policy,json=iceTransportPolicy,proto3" json:"iceTransportPolicy,omitempty"`
	// IceCandidatePoolSize defines the size of the prefetched ICE pool.
	// Optional.
	IceCandidatePoolSize uint32 `protobuf:"varint,3,opt,name=ice_candidate_pool_size,json=iceCandidatePoolSize,proto3" json:"iceCandidatePoolSize,omitempty"`
}

func (x *WebRtcConfig) Reset() {
	*x = WebRtcConfig{}
}

func (*WebRtcConfig) ProtoMessage() {}

func (x *WebRtcConfig) GetIceServers() []*IceServerConfig {
	if x != nil {
		return x.IceServers
	}
	return nil
}

func (x *WebRtcConfig) GetIceTransportPolicy() IceTransportPolicy {
	if x != nil {
		return x.IceTransportPolicy
	}
	return IceTransportPolicy_IceTransportPolicy_ALL
}

func (x *WebRtcConfig) GetIceCandidatePoolSize() uint32 {
	if x != nil {
		return x.IceCandidatePoolSize
	}
	return 0
}

// IceServer is a WebRTC ICE server config.
type IceServerConfig struct {
	unknownFields []byte
	// Urls is the list of URLs for the ICE server.
	//
	// Format: stun:{url} or turn:{url} or turns:{url}?transport=tcp
	// Examples:
	// - stun:stun.l.google.com:19302
	// - stun:stun.stunprotocol.org:3478
	// - turns:google.de?transport=tcp
	Urls []string `protobuf:"bytes,1,rep,name=urls,proto3" json:"urls,omitempty"`
	// Username is the username for the ICE server.
	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"`
	// Credential contains the ice server credential, if any.
	//
	// Types that are assignable to Credential:
	//
	//	*IceServerConfig_Password
	//	*IceServerConfig_Oauth
	Credential isIceServerConfig_Credential `protobuf_oneof:"credential"`
}

func (x *IceServerConfig) Reset() {
	*x = IceServerConfig{}
}

func (*IceServerConfig) ProtoMessage() {}

func (x *IceServerConfig) GetUrls() []string {
	if x != nil {
		return x.Urls
	}
	return nil
}

func (x *IceServerConfig) GetUsername() string {
	if x != nil {
		return x.Username
	}
	return ""
}

func (m *IceServerConfig) GetCredential() isIceServerConfig_Credential {
	if m != nil {
		return m.Credential
	}
	return nil
}

func (x *IceServerConfig) GetPassword() string {
	if x, ok := x.GetCredential().(*IceServerConfig_Password); ok {
		return x.Password
	}
	return ""
}

func (x *IceServerConfig) GetOauth() *IceServerConfig_OauthCredential {
	if x, ok := x.GetCredential().(*IceServerConfig_Oauth); ok {
		return x.Oauth
	}
	return nil
}

type isIceServerConfig_Credential interface {
	isIceServerConfig_Credential()
}

type IceServerConfig_Password struct {
	// Password contains the ICE server password.
	Password string `protobuf:"bytes,3,opt,name=password,proto3,oneof"`
}

type IceServerConfig_Oauth struct {
	// Oauth contains an OAuth credential.
	Oauth *IceServerConfig_OauthCredential `protobuf:"bytes,4,opt,name=oauth,proto3,oneof"`
}

func (*IceServerConfig_Password) isIceServerConfig_Credential() {}

func (*IceServerConfig_Oauth) isIceServerConfig_Credential() {}

// WebRtcSignal is a WebRTC Signaling message sent via the Signaling channel.
type WebRtcSignal struct {
	unknownFields []byte
	// Body is the body of the message.
	//
	// Types that are assignable to Body:
	//
	//	*WebRtcSignal_RequestOffer
	//	*WebRtcSignal_Sdp
	//	*WebRtcSignal_Ice
	Body isWebRtcSignal_Body `protobuf_oneof:"body"`
}

func (x *WebRtcSignal) Reset() {
	*x = WebRtcSignal{}
}

func (*WebRtcSignal) ProtoMessage() {}

func (m *WebRtcSignal) GetBody() isWebRtcSignal_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *WebRtcSignal) GetRequestOffer() uint64 {
	if x, ok := x.GetBody().(*WebRtcSignal_RequestOffer); ok {
		return x.RequestOffer
	}
	return 0
}

func (x *WebRtcSignal) GetSdp() *WebRtcSdp {
	if x, ok := x.GetBody().(*WebRtcSignal_Sdp); ok {
		return x.Sdp
	}
	return nil
}

func (x *WebRtcSignal) GetIce() *WebRtcIce {
	if x, ok := x.GetBody().(*WebRtcSignal_Ice); ok {
		return x.Ice
	}
	return nil
}

type isWebRtcSignal_Body interface {
	isWebRtcSignal_Body()
}

type WebRtcSignal_RequestOffer struct {
	// RequestOffer requests a new offer from the offerer with the local session seqno.
	// Incremented when negotiation is needed (something changes about the session).
	RequestOffer uint64 `protobuf:"varint,1,opt,name=request_offer,json=requestOffer,proto3,oneof"`
}

type WebRtcSignal_Sdp struct {
	// Sdp contains the sdp offer or answer.
	Sdp *WebRtcSdp `protobuf:"bytes,2,opt,name=sdp,proto3,oneof"`
}

type WebRtcSignal_Ice struct {
	// Ice contains an ICE candidate.
	Ice *WebRtcIce `protobuf:"bytes,3,opt,name=ice,proto3,oneof"`
}

func (*WebRtcSignal_RequestOffer) isWebRtcSignal_Body() {}

func (*WebRtcSignal_Sdp) isWebRtcSignal_Body() {}

func (*WebRtcSignal_Ice) isWebRtcSignal_Body() {}

// WebRtcSdp contains the SDP offer or answer.
type WebRtcSdp struct {
	unknownFields []byte
	// TxSeqno is the sequence number of the transmitting peer.
	// The receiver should update the local seqno to match.
	TxSeqno uint64 `protobuf:"varint,1,opt,name=tx_seqno,json=txSeqno,proto3" json:"txSeqno,omitempty"`
	// SdpType is the string encoded type of the sdp.
	// Examples: "offer" "answer"
	SdpType string `protobuf:"bytes,2,opt,name=sdp_type,json=sdpType,proto3" json:"sdpType,omitempty"`
	// Sdp contains the WebRTC session description.
	Sdp string `protobuf:"bytes,3,opt,name=sdp,proto3" json:"sdp,omitempty"`
}

func (x *WebRtcSdp) Reset() {
	*x = WebRtcSdp{}
}

func (*WebRtcSdp) ProtoMessage() {}

func (x *WebRtcSdp) GetTxSeqno() uint64 {
	if x != nil {
		return x.TxSeqno
	}
	return 0
}

func (x *WebRtcSdp) GetSdpType() string {
	if x != nil {
		return x.SdpType
	}
	return ""
}

func (x *WebRtcSdp) GetSdp() string {
	if x != nil {
		return x.Sdp
	}
	return ""
}

// WebRtcIce contains an ICE candidate.
type WebRtcIce struct {
	unknownFields []byte
	// Candidate contains the JSON-encoded ICE candidate.
	Candidate string `protobuf:"bytes,1,opt,name=candidate,proto3" json:"candidate,omitempty"`
}

func (x *WebRtcIce) Reset() {
	*x = WebRtcIce{}
}

func (*WebRtcIce) ProtoMessage() {}

func (x *WebRtcIce) GetCandidate() string {
	if x != nil {
		return x.Candidate
	}
	return ""
}

type Config_DialersEntry struct {
	unknownFields []byte
	Key           string             `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         *dialer.DialerOpts `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (x *Config_DialersEntry) Reset() {
	*x = Config_DialersEntry{}
}

func (*Config_DialersEntry) ProtoMessage() {}

func (x *Config_DialersEntry) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *Config_DialersEntry) GetValue() *dialer.DialerOpts {
	if x != nil {
		return x.Value
	}
	return nil
}

// OauthCredential is an OAuth credential information for the ICE server.
type IceServerConfig_OauthCredential struct {
	unknownFields []byte
	// MacKey is a base64-url format.
	MacKey string `protobuf:"bytes,1,opt,name=mac_key,json=macKey,proto3" json:"macKey,omitempty"`
	// AccessToken is the access token in base64-encoded format.
	AccessToken string `protobuf:"bytes,2,opt,name=access_token,json=accessToken,proto3" json:"accessToken,omitempty"`
}

func (x *IceServerConfig_OauthCredential) Reset() {
	*x = IceServerConfig_OauthCredential{}
}

func (*IceServerConfig_OauthCredential) ProtoMessage() {}

func (x *IceServerConfig_OauthCredential) GetMacKey() string {
	if x != nil {
		return x.MacKey
	}
	return ""
}

func (x *IceServerConfig_OauthCredential) GetAccessToken() string {
	if x != nil {
		return x.AccessToken
	}
	return ""
}

func (m *Config) CloneVT() *Config {
	if m == nil {
		return (*Config)(nil)
	}
	r := new(Config)
	r.SignalingId = m.SignalingId
	r.TransportPeerId = m.TransportPeerId
	r.TransportType = m.TransportType
	r.WebRtc = m.WebRtc.CloneVT()
	r.AllPeers = m.AllPeers
	r.DisableListen = m.DisableListen
	r.Verbose = m.Verbose
	if rhs := m.Quic; rhs != nil {
		r.Quic = rhs.CloneVT()
	}
	if rhs := m.Backoff; rhs != nil {
		r.Backoff = rhs.CloneVT()
	}
	if rhs := m.Dialers; rhs != nil {
		tmpContainer := make(map[string]*dialer.DialerOpts, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Dialers = tmpContainer
	}
	if rhs := m.BlockPeers; rhs != nil {
		tmpContainer := make([]string, len(rhs))
		copy(tmpContainer, rhs)
		r.BlockPeers = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *Config) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebRtcConfig) CloneVT() *WebRtcConfig {
	if m == nil {
		return (*WebRtcConfig)(nil)
	}
	r := new(WebRtcConfig)
	r.IceTransportPolicy = m.IceTransportPolicy
	r.IceCandidatePoolSize = m.IceCandidatePoolSize
	if rhs := m.IceServers; rhs != nil {
		tmpContainer := make([]*IceServerConfig, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.IceServers = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *WebRtcConfig) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *IceServerConfig_OauthCredential) CloneVT() *IceServerConfig_OauthCredential {
	if m == nil {
		return (*IceServerConfig_OauthCredential)(nil)
	}
	r := new(IceServerConfig_OauthCredential)
	r.MacKey = m.MacKey
	r.AccessToken = m.AccessToken
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *IceServerConfig_OauthCredential) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *IceServerConfig) CloneVT() *IceServerConfig {
	if m == nil {
		return (*IceServerConfig)(nil)
	}
	r := new(IceServerConfig)
	r.Username = m.Username
	if rhs := m.Urls; rhs != nil {
		tmpContainer := make([]string, len(rhs))
		copy(tmpContainer, rhs)
		r.Urls = tmpContainer
	}
	if m.Credential != nil {
		r.Credential = m.Credential.(interface {
			CloneOneofVT() isIceServerConfig_Credential
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *IceServerConfig) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *IceServerConfig_Password) CloneVT() *IceServerConfig_Password {
	if m == nil {
		return (*IceServerConfig_Password)(nil)
	}
	r := new(IceServerConfig_Password)
	r.Password = m.Password
	return r
}

func (m *IceServerConfig_Password) CloneOneofVT() isIceServerConfig_Credential {
	return m.CloneVT()
}

func (m *IceServerConfig_Oauth) CloneVT() *IceServerConfig_Oauth {
	if m == nil {
		return (*IceServerConfig_Oauth)(nil)
	}
	r := new(IceServerConfig_Oauth)
	r.Oauth = m.Oauth.CloneVT()
	return r
}

func (m *IceServerConfig_Oauth) CloneOneofVT() isIceServerConfig_Credential {
	return m.CloneVT()
}

func (m *WebRtcSignal) CloneVT() *WebRtcSignal {
	if m == nil {
		return (*WebRtcSignal)(nil)
	}
	r := new(WebRtcSignal)
	if m.Body != nil {
		r.Body = m.Body.(interface{ CloneOneofVT() isWebRtcSignal_Body }).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *WebRtcSignal) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebRtcSignal_RequestOffer) CloneVT() *WebRtcSignal_RequestOffer {
	if m == nil {
		return (*WebRtcSignal_RequestOffer)(nil)
	}
	r := new(WebRtcSignal_RequestOffer)
	r.RequestOffer = m.RequestOffer
	return r
}

func (m *WebRtcSignal_RequestOffer) CloneOneofVT() isWebRtcSignal_Body {
	return m.CloneVT()
}

func (m *WebRtcSignal_Sdp) CloneVT() *WebRtcSignal_Sdp {
	if m == nil {
		return (*WebRtcSignal_Sdp)(nil)
	}
	r := new(WebRtcSignal_Sdp)
	r.Sdp = m.Sdp.CloneVT()
	return r
}

func (m *WebRtcSignal_Sdp) CloneOneofVT() isWebRtcSignal_Body {
	return m.CloneVT()
}

func (m *WebRtcSignal_Ice) CloneVT() *WebRtcSignal_Ice {
	if m == nil {
		return (*WebRtcSignal_Ice)(nil)
	}
	r := new(WebRtcSignal_Ice)
	r.Ice = m.Ice.CloneVT()
	return r
}

func (m *WebRtcSignal_Ice) CloneOneofVT() isWebRtcSignal_Body {
	return m.CloneVT()
}

func (m *WebRtcSdp) CloneVT() *WebRtcSdp {
	if m == nil {
		return (*WebRtcSdp)(nil)
	}
	r := new(WebRtcSdp)
	r.TxSeqno = m.TxSeqno
	r.SdpType = m.SdpType
	r.Sdp = m.Sdp
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *WebRtcSdp) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebRtcIce) CloneVT() *WebRtcIce {
	if m == nil {
		return (*WebRtcIce)(nil)
	}
	r := new(WebRtcIce)
	r.Candidate = m.Candidate
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *WebRtcIce) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *Config) EqualVT(that *Config) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.SignalingId != that.SignalingId {
		return false
	}
	if this.TransportPeerId != that.TransportPeerId {
		return false
	}
	if this.TransportType != that.TransportType {
		return false
	}
	if !this.Quic.EqualVT(that.Quic) {
		return false
	}
	if !this.WebRtc.EqualVT(that.WebRtc) {
		return false
	}
	if !this.Backoff.EqualVT(that.Backoff) {
		return false
	}
	if len(this.Dialers) != len(that.Dialers) {
		return false
	}
	for i, vx := range this.Dialers {
		vy, ok := that.Dialers[i]
		if !ok {
			return false
		}
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &dialer.DialerOpts{}
			}
			if q == nil {
				q = &dialer.DialerOpts{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	if this.AllPeers != that.AllPeers {
		return false
	}
	if this.DisableListen != that.DisableListen {
		return false
	}
	if len(this.BlockPeers) != len(that.BlockPeers) {
		return false
	}
	for i, vx := range this.BlockPeers {
		vy := that.BlockPeers[i]
		if vx != vy {
			return false
		}
	}
	if this.Verbose != that.Verbose {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Config) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Config)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *WebRtcConfig) EqualVT(that *WebRtcConfig) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if len(this.IceServers) != len(that.IceServers) {
		return false
	}
	for i, vx := range this.IceServers {
		vy := that.IceServers[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &IceServerConfig{}
			}
			if q == nil {
				q = &IceServerConfig{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	if this.IceTransportPolicy != that.IceTransportPolicy {
		return false
	}
	if this.IceCandidatePoolSize != that.IceCandidatePoolSize {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebRtcConfig) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebRtcConfig)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *IceServerConfig_OauthCredential) EqualVT(that *IceServerConfig_OauthCredential) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.MacKey != that.MacKey {
		return false
	}
	if this.AccessToken != that.AccessToken {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *IceServerConfig_OauthCredential) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*IceServerConfig_OauthCredential)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *IceServerConfig) EqualVT(that *IceServerConfig) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Credential == nil && that.Credential != nil {
		return false
	} else if this.Credential != nil {
		if that.Credential == nil {
			return false
		}
		if !this.Credential.(interface {
			EqualVT(isIceServerConfig_Credential) bool
		}).EqualVT(that.Credential) {
			return false
		}
	}
	if len(this.Urls) != len(that.Urls) {
		return false
	}
	for i, vx := range this.Urls {
		vy := that.Urls[i]
		if vx != vy {
			return false
		}
	}
	if this.Username != that.Username {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *IceServerConfig) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*IceServerConfig)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *IceServerConfig_Password) EqualVT(thatIface isIceServerConfig_Credential) bool {
	that, ok := thatIface.(*IceServerConfig_Password)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if this.Password != that.Password {
		return false
	}
	return true
}

func (this *IceServerConfig_Oauth) EqualVT(thatIface isIceServerConfig_Credential) bool {
	that, ok := thatIface.(*IceServerConfig_Oauth)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if p, q := this.Oauth, that.Oauth; p != q {
		if p == nil {
			p = &IceServerConfig_OauthCredential{}
		}
		if q == nil {
			q = &IceServerConfig_OauthCredential{}
		}
		if !p.EqualVT(q) {
			return false
		}
	}
	return true
}

func (this *WebRtcSignal) EqualVT(that *WebRtcSignal) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isWebRtcSignal_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebRtcSignal) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebRtcSignal)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *WebRtcSignal_RequestOffer) EqualVT(thatIface isWebRtcSignal_Body) bool {
	that, ok := thatIface.(*WebRtcSignal_RequestOffer)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if this.RequestOffer != that.RequestOffer {
		return false
	}
	return true
}

func (this *WebRtcSignal_Sdp) EqualVT(thatIface isWebRtcSignal_Body) bool {
	that, ok := thatIface.(*WebRtcSignal_Sdp)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if p, q := this.Sdp, that.Sdp; p != q {
		if p == nil {
			p = &WebRtcSdp{}
		}
		if q == nil {
			q = &WebRtcSdp{}
		}
		if !p.EqualVT(q) {
			return false
		}
	}
	return true
}

func (this *WebRtcSignal_Ice) EqualVT(thatIface isWebRtcSignal_Body) bool {
	that, ok := thatIface.(*WebRtcSignal_Ice)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if p, q := this.Ice, that.Ice; p != q {
		if p == nil {
			p = &WebRtcIce{}
		}
		if q == nil {
			q = &WebRtcIce{}
		}
		if !p.EqualVT(q) {
			return false
		}
	}
	return true
}

func (this *WebRtcSdp) EqualVT(that *WebRtcSdp) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.TxSeqno != that.TxSeqno {
		return false
	}
	if this.SdpType != that.SdpType {
		return false
	}
	if this.Sdp != that.Sdp {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebRtcSdp) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebRtcSdp)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *WebRtcIce) EqualVT(that *WebRtcIce) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Candidate != that.Candidate {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebRtcIce) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebRtcIce)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// MarshalProtoJSON marshals the IceTransportPolicy to JSON.
func (x IceTransportPolicy) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnumString(int32(x), IceTransportPolicy_name)
}

// MarshalText marshals the IceTransportPolicy to text.
func (x IceTransportPolicy) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), IceTransportPolicy_name)), nil
}

// MarshalJSON marshals the IceTransportPolicy to JSON.
func (x IceTransportPolicy) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the IceTransportPolicy from JSON.
func (x *IceTransportPolicy) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(IceTransportPolicy_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read IceTransportPolicy enum: %v", err)
		return
	}
	*x = IceTransportPolicy(v)
}

// UnmarshalText unmarshals the IceTransportPolicy from text.
func (x *IceTransportPolicy) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), IceTransportPolicy_value)
	if err != nil {
		return err
	}
	*x = IceTransportPolicy(i)
	return nil
}

// UnmarshalJSON unmarshals the IceTransportPolicy from JSON.
func (x *IceTransportPolicy) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Config_DialersEntry message to JSON.
func (x *Config_DialersEntry) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Key != "" || s.HasField("key") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("key")
		s.WriteString(x.Key)
	}
	if x.Value != nil || s.HasField("value") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("value")
		x.Value.MarshalProtoJSON(s.WithField("value"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the Config_DialersEntry to JSON.
func (x *Config_DialersEntry) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the Config_DialersEntry message from JSON.
func (x *Config_DialersEntry) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "key":
			s.AddField("key")
			x.Key = s.ReadString()
		case "value":
			if s.ReadNil() {
				x.Value = nil
				return
			}
			x.Value = &dialer.DialerOpts{}
			x.Value.UnmarshalProtoJSON(s.WithField("value", true))
		}
	})
}

// UnmarshalJSON unmarshals the Config_DialersEntry from JSON.
func (x *Config_DialersEntry) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Config message to JSON.
func (x *Config) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.SignalingId != "" || s.HasField("signalingId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("signalingId")
		s.WriteString(x.SignalingId)
	}
	if x.TransportPeerId != "" || s.HasField("transportPeerId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("transportPeerId")
		s.WriteString(x.TransportPeerId)
	}
	if x.TransportType != "" || s.HasField("transportType") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("transportType")
		s.WriteString(x.TransportType)
	}
	if x.Quic != nil || s.HasField("quic") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("quic")
		x.Quic.MarshalProtoJSON(s.WithField("quic"))
	}
	if x.WebRtc != nil || s.HasField("webRtc") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("webRtc")
		x.WebRtc.MarshalProtoJSON(s.WithField("webRtc"))
	}
	if x.Backoff != nil || s.HasField("backoff") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("backoff")
		x.Backoff.MarshalProtoJSON(s.WithField("backoff"))
	}
	if x.Dialers != nil || s.HasField("dialers") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dialers")
		s.WriteObjectStart()
		var wroteElement bool
		for k, v := range x.Dialers {
			s.WriteMoreIf(&wroteElement)
			s.WriteObjectStringField(k)
			v.MarshalProtoJSON(s.WithField("dialers"))
		}
		s.WriteObjectEnd()
	}
	if x.AllPeers || s.HasField("allPeers") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("allPeers")
		s.WriteBool(x.AllPeers)
	}
	if x.DisableListen || s.HasField("disableListen") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("disableListen")
		s.WriteBool(x.DisableListen)
	}
	if len(x.BlockPeers) > 0 || s.HasField("blockPeers") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("blockPeers")
		s.WriteStringArray(x.BlockPeers)
	}
	if x.Verbose || s.HasField("verbose") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("verbose")
		s.WriteBool(x.Verbose)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the Config to JSON.
func (x *Config) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the Config message from JSON.
func (x *Config) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "signaling_id", "signalingId":
			s.AddField("signaling_id")
			x.SignalingId = s.ReadString()
		case "transport_peer_id", "transportPeerId":
			s.AddField("transport_peer_id")
			x.TransportPeerId = s.ReadString()
		case "transport_type", "transportType":
			s.AddField("transport_type")
			x.TransportType = s.ReadString()
		case "quic":
			if s.ReadNil() {
				x.Quic = nil
				return
			}
			x.Quic = &quic.Opts{}
			x.Quic.UnmarshalProtoJSON(s.WithField("quic", true))
		case "web_rtc", "webRtc":
			if s.ReadNil() {
				x.WebRtc = nil
				return
			}
			x.WebRtc = &WebRtcConfig{}
			x.WebRtc.UnmarshalProtoJSON(s.WithField("web_rtc", true))
		case "backoff":
			if s.ReadNil() {
				x.Backoff = nil
				return
			}
			x.Backoff = &backoff.Backoff{}
			x.Backoff.UnmarshalProtoJSON(s.WithField("backoff", true))
		case "dialers":
			s.AddField("dialers")
			if s.ReadNil() {
				x.Dialers = nil
				return
			}
			x.Dialers = make(map[string]*dialer.DialerOpts)
			s.ReadStringMap(func(key string) {
				var v dialer.DialerOpts
				v.UnmarshalProtoJSON(s)
				x.Dialers[key] = &v
			})
		case "all_peers", "allPeers":
			s.AddField("all_peers")
			x.AllPeers = s.ReadBool()
		case "disable_listen", "disableListen":
			s.AddField("disable_listen")
			x.DisableListen = s.ReadBool()
		case "block_peers", "blockPeers":
			s.AddField("block_peers")
			if s.ReadNil() {
				x.BlockPeers = nil
				return
			}
			x.BlockPeers = s.ReadStringArray()
		case "verbose":
			s.AddField("verbose")
			x.Verbose = s.ReadBool()
		}
	})
}

// UnmarshalJSON unmarshals the Config from JSON.
func (x *Config) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebRtcConfig message to JSON.
func (x *WebRtcConfig) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.IceServers) > 0 || s.HasField("iceServers") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("iceServers")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.IceServers {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("iceServers"))
		}
		s.WriteArrayEnd()
	}
	if x.IceTransportPolicy != 0 || s.HasField("iceTransportPolicy") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("iceTransportPolicy")
		x.IceTransportPolicy.MarshalProtoJSON(s)
	}
	if x.IceCandidatePoolSize != 0 || s.HasField("iceCandidatePoolSize") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("iceCandidatePoolSize")
		s.WriteUint32(x.IceCandidatePoolSize)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebRtcConfig to JSON.
func (x *WebRtcConfig) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebRtcConfig message from JSON.
func (x *WebRtcConfig) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "ice_servers", "iceServers":
			s.AddField("ice_servers")
			if s.ReadNil() {
				x.IceServers = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.IceServers = append(x.IceServers, nil)
					return
				}
				v := &IceServerConfig{}
				v.UnmarshalProtoJSON(s.WithField("ice_servers", false))
				if s.Err() != nil {
					return
				}
				x.IceServers = append(x.IceServers, v)
			})
		case "ice_transport_policy", "iceTransportPolicy":
			s.AddField("ice_transport_policy")
			x.IceTransportPolicy.UnmarshalProtoJSON(s)
		case "ice_candidate_pool_size", "iceCandidatePoolSize":
			s.AddField("ice_candidate_pool_size")
			x.IceCandidatePoolSize = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the WebRtcConfig from JSON.
func (x *WebRtcConfig) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the IceServerConfig_OauthCredential message to JSON.
func (x *IceServerConfig_OauthCredential) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MacKey != "" || s.HasField("macKey") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("macKey")
		s.WriteString(x.MacKey)
	}
	if x.AccessToken != "" || s.HasField("accessToken") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("accessToken")
		s.WriteString(x.AccessToken)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the IceServerConfig_OauthCredential to JSON.
func (x *IceServerConfig_OauthCredential) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the IceServerConfig_OauthCredential message from JSON.
func (x *IceServerConfig_OauthCredential) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "mac_key", "macKey":
			s.AddField("mac_key")
			x.MacKey = s.ReadString()
		case "access_token", "accessToken":
			s.AddField("access_token")
			x.AccessToken = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the IceServerConfig_OauthCredential from JSON.
func (x *IceServerConfig_OauthCredential) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the IceServerConfig message to JSON.
func (x *IceServerConfig) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.Urls) > 0 || s.HasField("urls") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("urls")
		s.WriteStringArray(x.Urls)
	}
	if x.Username != "" || s.HasField("username") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("username")
		s.WriteString(x.Username)
	}
	if x.Credential != nil {
		switch ov := x.Credential.(type) {
		case *IceServerConfig_Password:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("password")
			s.WriteString(ov.Password)
		case *IceServerConfig_Oauth:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("oauth")
			ov.Oauth.MarshalProtoJSON(s.WithField("oauth"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the IceServerConfig to JSON.
func (x *IceServerConfig) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the IceServerConfig message from JSON.
func (x *IceServerConfig) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "urls":
			s.AddField("urls")
			if s.ReadNil() {
				x.Urls = nil
				return
			}
			x.Urls = s.ReadStringArray()
		case "username":
			s.AddField("username")
			x.Username = s.ReadString()
		case "password":
			s.AddField("password")
			ov := &IceServerConfig_Password{}
			x.Credential = ov
			ov.Password = s.ReadString()
		case "oauth":
			ov := &IceServerConfig_Oauth{}
			x.Credential = ov
			if s.ReadNil() {
				ov.Oauth = nil
				return
			}
			ov.Oauth = &IceServerConfig_OauthCredential{}
			ov.Oauth.UnmarshalProtoJSON(s.WithField("oauth", true))
		}
	})
}

// UnmarshalJSON unmarshals the IceServerConfig from JSON.
func (x *IceServerConfig) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebRtcSignal message to JSON.
func (x *WebRtcSignal) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *WebRtcSignal_RequestOffer:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("requestOffer")
			s.WriteUint64(ov.RequestOffer)
		case *WebRtcSignal_Sdp:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("sdp")
			ov.Sdp.MarshalProtoJSON(s.WithField("sdp"))
		case *WebRtcSignal_Ice:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ice")
			ov.Ice.MarshalProtoJSON(s.WithField("ice"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebRtcSignal to JSON.
func (x *WebRtcSignal) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebRtcSignal message from JSON.
func (x *WebRtcSignal) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "request_offer", "requestOffer":
			s.AddField("request_offer")
			ov := &WebRtcSignal_RequestOffer{}
			x.Body = ov
			ov.RequestOffer = s.ReadUint64()
		case "sdp":
			ov := &WebRtcSignal_Sdp{}
			x.Body = ov
			if s.ReadNil() {
				ov.Sdp = nil
				return
			}
			ov.Sdp = &WebRtcSdp{}
			ov.Sdp.UnmarshalProtoJSON(s.WithField("sdp", true))
		case "ice":
			ov := &WebRtcSignal_Ice{}
			x.Body = ov
			if s.ReadNil() {
				ov.Ice = nil
				return
			}
			ov.Ice = &WebRtcIce{}
			ov.Ice.UnmarshalProtoJSON(s.WithField("ice", true))
		}
	})
}

// UnmarshalJSON unmarshals the WebRtcSignal from JSON.
func (x *WebRtcSignal) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebRtcSdp message to JSON.
func (x *WebRtcSdp) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.TxSeqno != 0 || s.HasField("txSeqno") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("txSeqno")
		s.WriteUint64(x.TxSeqno)
	}
	if x.SdpType != "" || s.HasField("sdpType") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sdpType")
		s.WriteString(x.SdpType)
	}
	if x.Sdp != "" || s.HasField("sdp") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sdp")
		s.WriteString(x.Sdp)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebRtcSdp to JSON.
func (x *WebRtcSdp) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebRtcSdp message from JSON.
func (x *WebRtcSdp) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "tx_seqno", "txSeqno":
			s.AddField("tx_seqno")
			x.TxSeqno = s.ReadUint64()
		case "sdp_type", "sdpType":
			s.AddField("sdp_type")
			x.SdpType = s.ReadString()
		case "sdp":
			s.AddField("sdp")
			x.Sdp = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the WebRtcSdp from JSON.
func (x *WebRtcSdp) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebRtcIce message to JSON.
func (x *WebRtcIce) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Candidate != "" || s.HasField("candidate") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("candidate")
		s.WriteString(x.Candidate)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebRtcIce to JSON.
func (x *WebRtcIce) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebRtcIce message from JSON.
func (x *WebRtcIce) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "candidate":
			s.AddField("candidate")
			x.Candidate = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the WebRtcIce from JSON.
func (x *WebRtcIce) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

func (m *Config) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Config) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Config) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.Verbose {
		i--
		if m.Verbose {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if len(m.BlockPeers) > 0 {
		for iNdEx := len(m.BlockPeers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockPeers[iNdEx])
			copy(dAtA[i:], m.BlockPeers[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.BlockPeers[iNdEx])))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.DisableListen {
		i--
		if m.DisableListen {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if m.AllPeers {
		i--
		if m.AllPeers {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Dialers) > 0 {
		for k := range m.Dialers {
			v := m.Dialers[k]
			baseI := i
			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Backoff != nil {
		size, err := m.Backoff.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x32
	}
	if m.WebRtc != nil {
		size, err := m.WebRtc.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x2a
	}
	if m.Quic != nil {
		size, err := m.Quic.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TransportType) > 0 {
		i -= len(m.TransportType)
		copy(dAtA[i:], m.TransportType)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.TransportType)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TransportPeerId) > 0 {
		i -= len(m.TransportPeerId)
		copy(dAtA[i:], m.TransportPeerId)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.TransportPeerId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SignalingId) > 0 {
		i -= len(m.SignalingId)
		copy(dAtA[i:], m.SignalingId)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.SignalingId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WebRtcConfig) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebRtcConfig) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.IceCandidatePoolSize != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.IceCandidatePoolSize))
		i--
		dAtA[i] = 0x18
	}
	if m.IceTransportPolicy != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.IceTransportPolicy))
		i--
		dAtA[i] = 0x10
	}
	if len(m.IceServers) > 0 {
		for iNdEx := len(m.IceServers) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.IceServers[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *IceServerConfig_OauthCredential) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IceServerConfig_OauthCredential) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *IceServerConfig_OauthCredential) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.AccessToken) > 0 {
		i -= len(m.AccessToken)
		copy(dAtA[i:], m.AccessToken)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.AccessToken)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.MacKey) > 0 {
		i -= len(m.MacKey)
		copy(dAtA[i:], m.MacKey)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.MacKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IceServerConfig) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IceServerConfig) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *IceServerConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if vtmsg, ok := m.Credential.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Urls) > 0 {
		for iNdEx := len(m.Urls) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Urls[iNdEx])
			copy(dAtA[i:], m.Urls[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Urls[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *IceServerConfig_Password) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *IceServerConfig_Password) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Password)
	copy(dAtA[i:], m.Password)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Password)))
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}
func (m *IceServerConfig_Oauth) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *IceServerConfig_Oauth) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Oauth != nil {
		size, err := m.Oauth.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *WebRtcSignal) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebRtcSignal) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcSignal) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	return len(dAtA) - i, nil
}

func (m *WebRtcSignal_RequestOffer) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcSignal_RequestOffer) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RequestOffer))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *WebRtcSignal_Sdp) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcSignal_Sdp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Sdp != nil {
		size, err := m.Sdp.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *WebRtcSignal_Ice) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcSignal_Ice) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Ice != nil {
		size, err := m.Ice.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *WebRtcSdp) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebRtcSdp) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcSdp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Sdp) > 0 {
		i -= len(m.Sdp)
		copy(dAtA[i:], m.Sdp)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Sdp)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SdpType) > 0 {
		i -= len(m.SdpType)
		copy(dAtA[i:], m.SdpType)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.SdpType)))
		i--
		dAtA[i] = 0x12
	}
	if m.TxSeqno != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.TxSeqno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WebRtcIce) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebRtcIce) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebRtcIce) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Candidate) > 0 {
		i -= len(m.Candidate)
		copy(dAtA[i:], m.Candidate)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Candidate)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Config) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SignalingId)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.TransportPeerId)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.TransportType)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.Quic != nil {
		l = m.Quic.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.WebRtc != nil {
		l = m.WebRtc.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.Backoff != nil {
		l = m.Backoff.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.Dialers) > 0 {
		for k, v := range m.Dialers {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.SizeVT()
			}
			l += 1 + protobuf_go_lite.SizeOfVarint(uint64(l))
			mapEntrySize := 1 + len(k) + protobuf_go_lite.SizeOfVarint(uint64(len(k))) + l
			n += mapEntrySize + 1 + protobuf_go_lite.SizeOfVarint(uint64(mapEntrySize))
		}
	}
	if m.AllPeers {
		n += 2
	}
	if m.DisableListen {
		n += 2
	}
	if len(m.BlockPeers) > 0 {
		for _, s := range m.BlockPeers {
			l = len(s)
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	if m.Verbose {
		n += 2
	}
	n += len(m.unknownFields)
	return n
}

func (m *WebRtcConfig) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.IceServers) > 0 {
		for _, e := range m.IceServers {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	if m.IceTransportPolicy != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.IceTransportPolicy))
	}
	if m.IceCandidatePoolSize != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.IceCandidatePoolSize))
	}
	n += len(m.unknownFields)
	return n
}

func (m *IceServerConfig_OauthCredential) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MacKey)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.AccessToken)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *IceServerConfig) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Urls) > 0 {
		for _, s := range m.Urls {
			l = len(s)
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if vtmsg, ok := m.Credential.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *IceServerConfig_Password) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Password)
	n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	return n
}
func (m *IceServerConfig_Oauth) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Oauth != nil {
		l = m.Oauth.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	} else {
		n += 2
	}
	return n
}
func (m *WebRtcSignal) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *WebRtcSignal_RequestOffer) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.RequestOffer))
	return n
}
func (m *WebRtcSignal_Sdp) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sdp != nil {
		l = m.Sdp.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	} else {
		n += 2
	}
	return n
}
func (m *WebRtcSignal_Ice) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ice != nil {
		l = m.Ice.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	} else {
		n += 2
	}
	return n
}
func (m *WebRtcSdp) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TxSeqno != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.TxSeqno))
	}
	l = len(m.SdpType)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.Sdp)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *WebRtcIce) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Candidate)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (x IceTransportPolicy) MarshalProtoText() string {
	return x.String()
}
func (x *Config_DialersEntry) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("DialersEntry { ")
	if x.Key != "" {
		sb.WriteString(" key: ")
		sb.WriteString(strconv.Quote(x.Key))
	}
	if x.Value != nil {
		sb.WriteString(" value: ")
		sb.WriteString(x.Value.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *Config_DialersEntry) String() string {
	return x.MarshalProtoText()
}
func (x *Config) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Config { ")
	if x.SignalingId != "" {
		sb.WriteString(" signaling_id: ")
		sb.WriteString(strconv.Quote(x.SignalingId))
	}
	if x.TransportPeerId != "" {
		sb.WriteString(" transport_peer_id: ")
		sb.WriteString(strconv.Quote(x.TransportPeerId))
	}
	if x.TransportType != "" {
		sb.WriteString(" transport_type: ")
		sb.WriteString(strconv.Quote(x.TransportType))
	}
	if x.Quic != nil {
		sb.WriteString(" quic: ")
		sb.WriteString(x.Quic.MarshalProtoText())
	}
	if x.WebRtc != nil {
		sb.WriteString(" web_rtc: ")
		sb.WriteString(x.WebRtc.MarshalProtoText())
	}
	if x.Backoff != nil {
		sb.WriteString(" backoff: ")
		sb.WriteString(x.Backoff.MarshalProtoText())
	}
	if len(x.Dialers) > 0 {
		sb.WriteString(" dialers: {")
		for k, v := range x.Dialers {
			sb.WriteString(" ")
			sb.WriteString(strconv.Quote(k))
			sb.WriteString(": ")
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString(" }")
	}
	if x.AllPeers {
		sb.WriteString(" all_peers: ")
		sb.WriteString(strconv.FormatBool(x.AllPeers))
	}
	if x.DisableListen {
		sb.WriteString(" disable_listen: ")
		sb.WriteString(strconv.FormatBool(x.DisableListen))
	}
	if len(x.BlockPeers) > 0 {
		sb.WriteString(" block_peers: [")
		for i, v := range x.BlockPeers {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.Quote(v))
		}
		sb.WriteString("]")
	}
	if x.Verbose {
		sb.WriteString(" verbose: ")
		sb.WriteString(strconv.FormatBool(x.Verbose))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *Config) String() string {
	return x.MarshalProtoText()
}
func (x *WebRtcConfig) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("WebRtcConfig { ")
	if len(x.IceServers) > 0 {
		sb.WriteString(" ice_servers: [")
		for i, v := range x.IceServers {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	if x.IceTransportPolicy != 0 {
		sb.WriteString(" ice_transport_policy: ")
		sb.WriteString(IceTransportPolicy(x.IceTransportPolicy).String())
	}
	if x.IceCandidatePoolSize != 0 {
		sb.WriteString(" ice_candidate_pool_size: ")
		sb.WriteString(strconv.FormatUint(uint64(x.IceCandidatePoolSize), 10))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *WebRtcConfig) String() string {
	return x.MarshalProtoText()
}
func (x *IceServerConfig_OauthCredential) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("OauthCredential { ")
	if x.MacKey != "" {
		sb.WriteString(" mac_key: ")
		sb.WriteString(strconv.Quote(x.MacKey))
	}
	if x.AccessToken != "" {
		sb.WriteString(" access_token: ")
		sb.WriteString(strconv.Quote(x.AccessToken))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *IceServerConfig_OauthCredential) String() string {
	return x.MarshalProtoText()
}
func (x *IceServerConfig) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("IceServerConfig { ")
	if len(x.Urls) > 0 {
		sb.WriteString(" urls: [")
		for i, v := range x.Urls {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.Quote(v))
		}
		sb.WriteString("]")
	}
	if x.Username != "" {
		sb.WriteString(" username: ")
		sb.WriteString(strconv.Quote(x.Username))
	}
	switch body := x.Credential.(type) {
	case *IceServerConfig_Password:
		if body.Password != "" {
			sb.WriteString(" password: ")
			sb.WriteString(strconv.Quote(body.Password))
		}
	case *IceServerConfig_Oauth:
		if body.Oauth != nil {
			sb.WriteString(" oauth: ")
			sb.WriteString(body.Oauth.MarshalProtoText())
		}
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *IceServerConfig) String() string {
	return x.MarshalProtoText()
}
func (x *WebRtcSignal) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("WebRtcSignal { ")
	switch body := x.Body.(type) {
	case *WebRtcSignal_RequestOffer:
		if body.RequestOffer != 0 {
			sb.WriteString(" request_offer: ")
			sb.WriteString(strconv.FormatUint(uint64(body.RequestOffer), 10))
		}
	case *WebRtcSignal_Sdp:
		if body.Sdp != nil {
			sb.WriteString(" sdp: ")
			sb.WriteString(body.Sdp.MarshalProtoText())
		}
	case *WebRtcSignal_Ice:
		if body.Ice != nil {
			sb.WriteString(" ice: ")
			sb.WriteString(body.Ice.MarshalProtoText())
		}
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *WebRtcSignal) String() string {
	return x.MarshalProtoText()
}
func (x *WebRtcSdp) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("WebRtcSdp { ")
	if x.TxSeqno != 0 {
		sb.WriteString(" tx_seqno: ")
		sb.WriteString(strconv.FormatUint(uint64(x.TxSeqno), 10))
	}
	if x.SdpType != "" {
		sb.WriteString(" sdp_type: ")
		sb.WriteString(strconv.Quote(x.SdpType))
	}
	if x.Sdp != "" {
		sb.WriteString(" sdp: ")
		sb.WriteString(strconv.Quote(x.Sdp))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *WebRtcSdp) String() string {
	return x.MarshalProtoText()
}
func (x *WebRtcIce) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("WebRtcIce { ")
	if x.Candidate != "" {
		sb.WriteString(" candidate: ")
		sb.WriteString(strconv.Quote(x.Candidate))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *WebRtcIce) String() string {
	return x.MarshalProtoText()
}
func (m *Config) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalingId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignalingId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportPeerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransportPeerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransportType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Quic == nil {
				m.Quic = &quic.Opts{}
			}
			if err := m.Quic.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WebRtc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WebRtc == nil {
				m.WebRtc = &WebRtcConfig{}
			}
			if err := m.WebRtc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Backoff", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Backoff == nil {
				m.Backoff = &backoff.Backoff{}
			}
			if err := m.Backoff.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dialers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dialers == nil {
				m.Dialers = make(map[string]*dialer.DialerOpts)
			}
			var mapkey string
			var mapvalue *dialer.DialerOpts
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &dialer.DialerOpts{}
					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Dialers[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllPeers", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllPeers = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableListen", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableListen = bool(v != 0)
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockPeers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockPeers = append(m.BlockPeers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verbose", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Verbose = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebRtcConfig) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebRtcConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebRtcConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IceServers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IceServers = append(m.IceServers, &IceServerConfig{})
			if err := m.IceServers[len(m.IceServers)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IceTransportPolicy", wireType)
			}
			m.IceTransportPolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IceTransportPolicy |= IceTransportPolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IceCandidatePoolSize", wireType)
			}
			m.IceCandidatePoolSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IceCandidatePoolSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IceServerConfig_OauthCredential) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IceServerConfig_OauthCredential: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IceServerConfig_OauthCredential: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MacKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessToken", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IceServerConfig) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IceServerConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IceServerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Urls", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Urls = append(m.Urls, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Credential = &IceServerConfig_Password{Password: string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Oauth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if oneof, ok := m.Credential.(*IceServerConfig_Oauth); ok {
				if err := oneof.Oauth.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
			} else {
				v := &IceServerConfig_OauthCredential{}
				if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				m.Credential = &IceServerConfig_Oauth{Oauth: v}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebRtcSignal) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebRtcSignal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebRtcSignal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestOffer", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Body = &WebRtcSignal_RequestOffer{RequestOffer: v}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sdp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if oneof, ok := m.Body.(*WebRtcSignal_Sdp); ok {
				if err := oneof.Sdp.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
			} else {
				v := &WebRtcSdp{}
				if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				m.Body = &WebRtcSignal_Sdp{Sdp: v}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if oneof, ok := m.Body.(*WebRtcSignal_Ice); ok {
				if err := oneof.Ice.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
			} else {
				v := &WebRtcIce{}
				if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				m.Body = &WebRtcSignal_Ice{Ice: v}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebRtcSdp) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebRtcSdp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebRtcSdp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxSeqno", wireType)
			}
			m.TxSeqno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxSeqno |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdpType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SdpType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sdp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sdp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WebRtcIce) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebRtcIce: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebRtcIce: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Candidate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Candidate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}