realtime.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: rtapi/realtime.proto

package rtapi

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	api "github.com/heroiclabs/nakama/api"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// The type of chat channel.
type ChannelJoin_Type int32

const (
	// Default case. Assumed as ROOM type.
	ChannelJoin_TYPE_UNSPECIFIED ChannelJoin_Type = 0
	// A room which anyone can join to chat.
	ChannelJoin_ROOM ChannelJoin_Type = 1
	// A private channel for 1-on-1 chat.
	ChannelJoin_DIRECT_MESSAGE ChannelJoin_Type = 2
	// A channel for group chat.
	ChannelJoin_GROUP ChannelJoin_Type = 3
)

var ChannelJoin_Type_name = map[int32]string{
	0: "TYPE_UNSPECIFIED",
	1: "ROOM",
	2: "DIRECT_MESSAGE",
	3: "GROUP",
}

var ChannelJoin_Type_value = map[string]int32{
	"TYPE_UNSPECIFIED": 0,
	"ROOM":             1,
	"DIRECT_MESSAGE":   2,
	"GROUP":            3,
}

func (x ChannelJoin_Type) String() string {
	return proto.EnumName(ChannelJoin_Type_name, int32(x))
}

func (ChannelJoin_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{2, 0}
}

// The selection of possible error codes.
type Error_Code int32

const (
	// An unexpected result from the server.
	Error_RUNTIME_EXCEPTION Error_Code = 0
	// The server received a message which is not recognised.
	Error_UNRECOGNIZED_PAYLOAD Error_Code = 1
	// A message was expected but contains no content.
	Error_MISSING_PAYLOAD Error_Code = 2
	// Fields in the message have an invalid format.
	Error_BAD_INPUT Error_Code = 3
	// The match id was not found.
	Error_MATCH_NOT_FOUND Error_Code = 4
	// The match join was rejected.
	Error_MATCH_JOIN_REJECTED Error_Code = 5
	// The runtime function does not exist on the server.
	Error_RUNTIME_FUNCTION_NOT_FOUND Error_Code = 6
	// The runtime function executed with an error.
	Error_RUNTIME_FUNCTION_EXCEPTION Error_Code = 7
)

var Error_Code_name = map[int32]string{
	0: "RUNTIME_EXCEPTION",
	1: "UNRECOGNIZED_PAYLOAD",
	2: "MISSING_PAYLOAD",
	3: "BAD_INPUT",
	4: "MATCH_NOT_FOUND",
	5: "MATCH_JOIN_REJECTED",
	6: "RUNTIME_FUNCTION_NOT_FOUND",
	7: "RUNTIME_FUNCTION_EXCEPTION",
}

var Error_Code_value = map[string]int32{
	"RUNTIME_EXCEPTION":          0,
	"UNRECOGNIZED_PAYLOAD":       1,
	"MISSING_PAYLOAD":            2,
	"BAD_INPUT":                  3,
	"MATCH_NOT_FOUND":            4,
	"MATCH_JOIN_REJECTED":        5,
	"RUNTIME_FUNCTION_NOT_FOUND": 6,
	"RUNTIME_FUNCTION_EXCEPTION": 7,
}

func (x Error_Code) String() string {
	return proto.EnumName(Error_Code_name, int32(x))
}

func (Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{9, 0}
}

// An envelope for a realtime message.
type Envelope struct {
	Cid string `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
	// Types that are valid to be assigned to Message:
	//	*Envelope_Channel
	//	*Envelope_ChannelJoin
	//	*Envelope_ChannelLeave
	//	*Envelope_ChannelMessage
	//	*Envelope_ChannelMessageAck
	//	*Envelope_ChannelMessageSend
	//	*Envelope_ChannelMessageUpdate
	//	*Envelope_ChannelMessageRemove
	//	*Envelope_ChannelPresenceEvent
	//	*Envelope_Error
	//	*Envelope_Match
	//	*Envelope_MatchCreate
	//	*Envelope_MatchData
	//	*Envelope_MatchDataSend
	//	*Envelope_MatchJoin
	//	*Envelope_MatchLeave
	//	*Envelope_MatchPresenceEvent
	//	*Envelope_MatchmakerAdd
	//	*Envelope_MatchmakerMatched
	//	*Envelope_MatchmakerRemove
	//	*Envelope_MatchmakerTicket
	//	*Envelope_Notifications
	//	*Envelope_Rpc
	//	*Envelope_Status
	//	*Envelope_StatusFollow
	//	*Envelope_StatusPresenceEvent
	//	*Envelope_StatusUnfollow
	//	*Envelope_StatusUpdate
	//	*Envelope_StreamData
	//	*Envelope_StreamPresenceEvent
	Message              isEnvelope_Message `protobuf_oneof:"message"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Envelope) Reset()         { *m = Envelope{} }
func (m *Envelope) String() string { return proto.CompactTextString(m) }
func (*Envelope) ProtoMessage()    {}
func (*Envelope) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{0}
}

func (m *Envelope) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Envelope.Unmarshal(m, b)
}
func (m *Envelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Envelope.Marshal(b, m, deterministic)
}
func (m *Envelope) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Envelope.Merge(m, src)
}
func (m *Envelope) XXX_Size() int {
	return xxx_messageInfo_Envelope.Size(m)
}
func (m *Envelope) XXX_DiscardUnknown() {
	xxx_messageInfo_Envelope.DiscardUnknown(m)
}

var xxx_messageInfo_Envelope proto.InternalMessageInfo

func (m *Envelope) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

type isEnvelope_Message interface {
	isEnvelope_Message()
}

type Envelope_Channel struct {
	Channel *Channel `protobuf:"bytes,2,opt,name=channel,proto3,oneof"`
}

type Envelope_ChannelJoin struct {
	ChannelJoin *ChannelJoin `protobuf:"bytes,3,opt,name=channel_join,json=channelJoin,proto3,oneof"`
}

type Envelope_ChannelLeave struct {
	ChannelLeave *ChannelLeave `protobuf:"bytes,4,opt,name=channel_leave,json=channelLeave,proto3,oneof"`
}

type Envelope_ChannelMessage struct {
	ChannelMessage *api.ChannelMessage `protobuf:"bytes,5,opt,name=channel_message,json=channelMessage,proto3,oneof"`
}

type Envelope_ChannelMessageAck struct {
	ChannelMessageAck *ChannelMessageAck `protobuf:"bytes,6,opt,name=channel_message_ack,json=channelMessageAck,proto3,oneof"`
}

type Envelope_ChannelMessageSend struct {
	ChannelMessageSend *ChannelMessageSend `protobuf:"bytes,7,opt,name=channel_message_send,json=channelMessageSend,proto3,oneof"`
}

type Envelope_ChannelMessageUpdate struct {
	ChannelMessageUpdate *ChannelMessageUpdate `protobuf:"bytes,8,opt,name=channel_message_update,json=channelMessageUpdate,proto3,oneof"`
}

type Envelope_ChannelMessageRemove struct {
	ChannelMessageRemove *ChannelMessageRemove `protobuf:"bytes,9,opt,name=channel_message_remove,json=channelMessageRemove,proto3,oneof"`
}

type Envelope_ChannelPresenceEvent struct {
	ChannelPresenceEvent *ChannelPresenceEvent `protobuf:"bytes,10,opt,name=channel_presence_event,json=channelPresenceEvent,proto3,oneof"`
}

type Envelope_Error struct {
	Error *Error `protobuf:"bytes,11,opt,name=error,proto3,oneof"`
}

type Envelope_Match struct {
	Match *Match `protobuf:"bytes,12,opt,name=match,proto3,oneof"`
}

type Envelope_MatchCreate struct {
	MatchCreate *MatchCreate `protobuf:"bytes,13,opt,name=match_create,json=matchCreate,proto3,oneof"`
}

type Envelope_MatchData struct {
	MatchData *MatchData `protobuf:"bytes,14,opt,name=match_data,json=matchData,proto3,oneof"`
}

type Envelope_MatchDataSend struct {
	MatchDataSend *MatchDataSend `protobuf:"bytes,15,opt,name=match_data_send,json=matchDataSend,proto3,oneof"`
}

type Envelope_MatchJoin struct {
	MatchJoin *MatchJoin `protobuf:"bytes,16,opt,name=match_join,json=matchJoin,proto3,oneof"`
}

type Envelope_MatchLeave struct {
	MatchLeave *MatchLeave `protobuf:"bytes,17,opt,name=match_leave,json=matchLeave,proto3,oneof"`
}

type Envelope_MatchPresenceEvent struct {
	MatchPresenceEvent *MatchPresenceEvent `protobuf:"bytes,18,opt,name=match_presence_event,json=matchPresenceEvent,proto3,oneof"`
}

type Envelope_MatchmakerAdd struct {
	MatchmakerAdd *MatchmakerAdd `protobuf:"bytes,19,opt,name=matchmaker_add,json=matchmakerAdd,proto3,oneof"`
}

type Envelope_MatchmakerMatched struct {
	MatchmakerMatched *MatchmakerMatched `protobuf:"bytes,20,opt,name=matchmaker_matched,json=matchmakerMatched,proto3,oneof"`
}

type Envelope_MatchmakerRemove struct {
	MatchmakerRemove *MatchmakerRemove `protobuf:"bytes,21,opt,name=matchmaker_remove,json=matchmakerRemove,proto3,oneof"`
}

type Envelope_MatchmakerTicket struct {
	MatchmakerTicket *MatchmakerTicket `protobuf:"bytes,22,opt,name=matchmaker_ticket,json=matchmakerTicket,proto3,oneof"`
}

type Envelope_Notifications struct {
	Notifications *Notifications `protobuf:"bytes,23,opt,name=notifications,proto3,oneof"`
}

type Envelope_Rpc struct {
	Rpc *api.Rpc `protobuf:"bytes,24,opt,name=rpc,proto3,oneof"`
}

type Envelope_Status struct {
	Status *Status `protobuf:"bytes,25,opt,name=status,proto3,oneof"`
}

type Envelope_StatusFollow struct {
	StatusFollow *StatusFollow `protobuf:"bytes,26,opt,name=status_follow,json=statusFollow,proto3,oneof"`
}

type Envelope_StatusPresenceEvent struct {
	StatusPresenceEvent *StatusPresenceEvent `protobuf:"bytes,27,opt,name=status_presence_event,json=statusPresenceEvent,proto3,oneof"`
}

type Envelope_StatusUnfollow struct {
	StatusUnfollow *StatusUnfollow `protobuf:"bytes,28,opt,name=status_unfollow,json=statusUnfollow,proto3,oneof"`
}

type Envelope_StatusUpdate struct {
	StatusUpdate *StatusUpdate `protobuf:"bytes,29,opt,name=status_update,json=statusUpdate,proto3,oneof"`
}

type Envelope_StreamData struct {
	StreamData *StreamData `protobuf:"bytes,30,opt,name=stream_data,json=streamData,proto3,oneof"`
}

type Envelope_StreamPresenceEvent struct {
	StreamPresenceEvent *StreamPresenceEvent `protobuf:"bytes,31,opt,name=stream_presence_event,json=streamPresenceEvent,proto3,oneof"`
}

func (*Envelope_Channel) isEnvelope_Message() {}

func (*Envelope_ChannelJoin) isEnvelope_Message() {}

func (*Envelope_ChannelLeave) isEnvelope_Message() {}

func (*Envelope_ChannelMessage) isEnvelope_Message() {}

func (*Envelope_ChannelMessageAck) isEnvelope_Message() {}

func (*Envelope_ChannelMessageSend) isEnvelope_Message() {}

func (*Envelope_ChannelMessageUpdate) isEnvelope_Message() {}

func (*Envelope_ChannelMessageRemove) isEnvelope_Message() {}

func (*Envelope_ChannelPresenceEvent) isEnvelope_Message() {}

func (*Envelope_Error) isEnvelope_Message() {}

func (*Envelope_Match) isEnvelope_Message() {}

func (*Envelope_MatchCreate) isEnvelope_Message() {}

func (*Envelope_MatchData) isEnvelope_Message() {}

func (*Envelope_MatchDataSend) isEnvelope_Message() {}

func (*Envelope_MatchJoin) isEnvelope_Message() {}

func (*Envelope_MatchLeave) isEnvelope_Message() {}

func (*Envelope_MatchPresenceEvent) isEnvelope_Message() {}

func (*Envelope_MatchmakerAdd) isEnvelope_Message() {}

func (*Envelope_MatchmakerMatched) isEnvelope_Message() {}

func (*Envelope_MatchmakerRemove) isEnvelope_Message() {}

func (*Envelope_MatchmakerTicket) isEnvelope_Message() {}

func (*Envelope_Notifications) isEnvelope_Message() {}

func (*Envelope_Rpc) isEnvelope_Message() {}

func (*Envelope_Status) isEnvelope_Message() {}

func (*Envelope_StatusFollow) isEnvelope_Message() {}

func (*Envelope_StatusPresenceEvent) isEnvelope_Message() {}

func (*Envelope_StatusUnfollow) isEnvelope_Message() {}

func (*Envelope_StatusUpdate) isEnvelope_Message() {}

func (*Envelope_StreamData) isEnvelope_Message() {}

func (*Envelope_StreamPresenceEvent) isEnvelope_Message() {}

func (m *Envelope) GetMessage() isEnvelope_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *Envelope) GetChannel() *Channel {
	if x, ok := m.GetMessage().(*Envelope_Channel); ok {
		return x.Channel
	}
	return nil
}

func (m *Envelope) GetChannelJoin() *ChannelJoin {
	if x, ok := m.GetMessage().(*Envelope_ChannelJoin); ok {
		return x.ChannelJoin
	}
	return nil
}

func (m *Envelope) GetChannelLeave() *ChannelLeave {
	if x, ok := m.GetMessage().(*Envelope_ChannelLeave); ok {
		return x.ChannelLeave
	}
	return nil
}

func (m *Envelope) GetChannelMessage() *api.ChannelMessage {
	if x, ok := m.GetMessage().(*Envelope_ChannelMessage); ok {
		return x.ChannelMessage
	}
	return nil
}

func (m *Envelope) GetChannelMessageAck() *ChannelMessageAck {
	if x, ok := m.GetMessage().(*Envelope_ChannelMessageAck); ok {
		return x.ChannelMessageAck
	}
	return nil
}

func (m *Envelope) GetChannelMessageSend() *ChannelMessageSend {
	if x, ok := m.GetMessage().(*Envelope_ChannelMessageSend); ok {
		return x.ChannelMessageSend
	}
	return nil
}

func (m *Envelope) GetChannelMessageUpdate() *ChannelMessageUpdate {
	if x, ok := m.GetMessage().(*Envelope_ChannelMessageUpdate); ok {
		return x.ChannelMessageUpdate
	}
	return nil
}

func (m *Envelope) GetChannelMessageRemove() *ChannelMessageRemove {
	if x, ok := m.GetMessage().(*Envelope_ChannelMessageRemove); ok {
		return x.ChannelMessageRemove
	}
	return nil
}

func (m *Envelope) GetChannelPresenceEvent() *ChannelPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_ChannelPresenceEvent); ok {
		return x.ChannelPresenceEvent
	}
	return nil
}

func (m *Envelope) GetError() *Error {
	if x, ok := m.GetMessage().(*Envelope_Error); ok {
		return x.Error
	}
	return nil
}

func (m *Envelope) GetMatch() *Match {
	if x, ok := m.GetMessage().(*Envelope_Match); ok {
		return x.Match
	}
	return nil
}

func (m *Envelope) GetMatchCreate() *MatchCreate {
	if x, ok := m.GetMessage().(*Envelope_MatchCreate); ok {
		return x.MatchCreate
	}
	return nil
}

func (m *Envelope) GetMatchData() *MatchData {
	if x, ok := m.GetMessage().(*Envelope_MatchData); ok {
		return x.MatchData
	}
	return nil
}

func (m *Envelope) GetMatchDataSend() *MatchDataSend {
	if x, ok := m.GetMessage().(*Envelope_MatchDataSend); ok {
		return x.MatchDataSend
	}
	return nil
}

func (m *Envelope) GetMatchJoin() *MatchJoin {
	if x, ok := m.GetMessage().(*Envelope_MatchJoin); ok {
		return x.MatchJoin
	}
	return nil
}

func (m *Envelope) GetMatchLeave() *MatchLeave {
	if x, ok := m.GetMessage().(*Envelope_MatchLeave); ok {
		return x.MatchLeave
	}
	return nil
}

func (m *Envelope) GetMatchPresenceEvent() *MatchPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_MatchPresenceEvent); ok {
		return x.MatchPresenceEvent
	}
	return nil
}

func (m *Envelope) GetMatchmakerAdd() *MatchmakerAdd {
	if x, ok := m.GetMessage().(*Envelope_MatchmakerAdd); ok {
		return x.MatchmakerAdd
	}
	return nil
}

func (m *Envelope) GetMatchmakerMatched() *MatchmakerMatched {
	if x, ok := m.GetMessage().(*Envelope_MatchmakerMatched); ok {
		return x.MatchmakerMatched
	}
	return nil
}

func (m *Envelope) GetMatchmakerRemove() *MatchmakerRemove {
	if x, ok := m.GetMessage().(*Envelope_MatchmakerRemove); ok {
		return x.MatchmakerRemove
	}
	return nil
}

func (m *Envelope) GetMatchmakerTicket() *MatchmakerTicket {
	if x, ok := m.GetMessage().(*Envelope_MatchmakerTicket); ok {
		return x.MatchmakerTicket
	}
	return nil
}

func (m *Envelope) GetNotifications() *Notifications {
	if x, ok := m.GetMessage().(*Envelope_Notifications); ok {
		return x.Notifications
	}
	return nil
}

func (m *Envelope) GetRpc() *api.Rpc {
	if x, ok := m.GetMessage().(*Envelope_Rpc); ok {
		return x.Rpc
	}
	return nil
}

func (m *Envelope) GetStatus() *Status {
	if x, ok := m.GetMessage().(*Envelope_Status); ok {
		return x.Status
	}
	return nil
}

func (m *Envelope) GetStatusFollow() *StatusFollow {
	if x, ok := m.GetMessage().(*Envelope_StatusFollow); ok {
		return x.StatusFollow
	}
	return nil
}

func (m *Envelope) GetStatusPresenceEvent() *StatusPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_StatusPresenceEvent); ok {
		return x.StatusPresenceEvent
	}
	return nil
}

func (m *Envelope) GetStatusUnfollow() *StatusUnfollow {
	if x, ok := m.GetMessage().(*Envelope_StatusUnfollow); ok {
		return x.StatusUnfollow
	}
	return nil
}

func (m *Envelope) GetStatusUpdate() *StatusUpdate {
	if x, ok := m.GetMessage().(*Envelope_StatusUpdate); ok {
		return x.StatusUpdate
	}
	return nil
}

func (m *Envelope) GetStreamData() *StreamData {
	if x, ok := m.GetMessage().(*Envelope_StreamData); ok {
		return x.StreamData
	}
	return nil
}

func (m *Envelope) GetStreamPresenceEvent() *StreamPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_StreamPresenceEvent); ok {
		return x.StreamPresenceEvent
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Envelope) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Envelope_OneofMarshaler, _Envelope_OneofUnmarshaler, _Envelope_OneofSizer, []interface{}{
		(*Envelope_Channel)(nil),
		(*Envelope_ChannelJoin)(nil),
		(*Envelope_ChannelLeave)(nil),
		(*Envelope_ChannelMessage)(nil),
		(*Envelope_ChannelMessageAck)(nil),
		(*Envelope_ChannelMessageSend)(nil),
		(*Envelope_ChannelMessageUpdate)(nil),
		(*Envelope_ChannelMessageRemove)(nil),
		(*Envelope_ChannelPresenceEvent)(nil),
		(*Envelope_Error)(nil),
		(*Envelope_Match)(nil),
		(*Envelope_MatchCreate)(nil),
		(*Envelope_MatchData)(nil),
		(*Envelope_MatchDataSend)(nil),
		(*Envelope_MatchJoin)(nil),
		(*Envelope_MatchLeave)(nil),
		(*Envelope_MatchPresenceEvent)(nil),
		(*Envelope_MatchmakerAdd)(nil),
		(*Envelope_MatchmakerMatched)(nil),
		(*Envelope_MatchmakerRemove)(nil),
		(*Envelope_MatchmakerTicket)(nil),
		(*Envelope_Notifications)(nil),
		(*Envelope_Rpc)(nil),
		(*Envelope_Status)(nil),
		(*Envelope_StatusFollow)(nil),
		(*Envelope_StatusPresenceEvent)(nil),
		(*Envelope_StatusUnfollow)(nil),
		(*Envelope_StatusUpdate)(nil),
		(*Envelope_StreamData)(nil),
		(*Envelope_StreamPresenceEvent)(nil),
	}
}

func _Envelope_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Envelope)
	// message
	switch x := m.Message.(type) {
	case *Envelope_Channel:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Channel); err != nil {
			return err
		}
	case *Envelope_ChannelJoin:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelJoin); err != nil {
			return err
		}
	case *Envelope_ChannelLeave:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelLeave); err != nil {
			return err
		}
	case *Envelope_ChannelMessage:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelMessage); err != nil {
			return err
		}
	case *Envelope_ChannelMessageAck:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelMessageAck); err != nil {
			return err
		}
	case *Envelope_ChannelMessageSend:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelMessageSend); err != nil {
			return err
		}
	case *Envelope_ChannelMessageUpdate:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelMessageUpdate); err != nil {
			return err
		}
	case *Envelope_ChannelMessageRemove:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelMessageRemove); err != nil {
			return err
		}
	case *Envelope_ChannelPresenceEvent:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelPresenceEvent); err != nil {
			return err
		}
	case *Envelope_Error:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *Envelope_Match:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Match); err != nil {
			return err
		}
	case *Envelope_MatchCreate:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchCreate); err != nil {
			return err
		}
	case *Envelope_MatchData:
		b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchData); err != nil {
			return err
		}
	case *Envelope_MatchDataSend:
		b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchDataSend); err != nil {
			return err
		}
	case *Envelope_MatchJoin:
		b.EncodeVarint(16<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchJoin); err != nil {
			return err
		}
	case *Envelope_MatchLeave:
		b.EncodeVarint(17<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchLeave); err != nil {
			return err
		}
	case *Envelope_MatchPresenceEvent:
		b.EncodeVarint(18<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchPresenceEvent); err != nil {
			return err
		}
	case *Envelope_MatchmakerAdd:
		b.EncodeVarint(19<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchmakerAdd); err != nil {
			return err
		}
	case *Envelope_MatchmakerMatched:
		b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchmakerMatched); err != nil {
			return err
		}
	case *Envelope_MatchmakerRemove:
		b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchmakerRemove); err != nil {
			return err
		}
	case *Envelope_MatchmakerTicket:
		b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchmakerTicket); err != nil {
			return err
		}
	case *Envelope_Notifications:
		b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Notifications); err != nil {
			return err
		}
	case *Envelope_Rpc:
		b.EncodeVarint(24<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Rpc); err != nil {
			return err
		}
	case *Envelope_Status:
		b.EncodeVarint(25<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Status); err != nil {
			return err
		}
	case *Envelope_StatusFollow:
		b.EncodeVarint(26<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StatusFollow); err != nil {
			return err
		}
	case *Envelope_StatusPresenceEvent:
		b.EncodeVarint(27<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StatusPresenceEvent); err != nil {
			return err
		}
	case *Envelope_StatusUnfollow:
		b.EncodeVarint(28<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StatusUnfollow); err != nil {
			return err
		}
	case *Envelope_StatusUpdate:
		b.EncodeVarint(29<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StatusUpdate); err != nil {
			return err
		}
	case *Envelope_StreamData:
		b.EncodeVarint(30<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StreamData); err != nil {
			return err
		}
	case *Envelope_StreamPresenceEvent:
		b.EncodeVarint(31<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StreamPresenceEvent); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Envelope.Message has unexpected type %T", x)
	}
	return nil
}

func _Envelope_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Envelope)
	switch tag {
	case 2: // message.channel
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Channel)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Channel{msg}
		return true, err
	case 3: // message.channel_join
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelJoin)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelJoin{msg}
		return true, err
	case 4: // message.channel_leave
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelLeave)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelLeave{msg}
		return true, err
	case 5: // message.channel_message
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(api.ChannelMessage)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelMessage{msg}
		return true, err
	case 6: // message.channel_message_ack
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelMessageAck)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelMessageAck{msg}
		return true, err
	case 7: // message.channel_message_send
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelMessageSend)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelMessageSend{msg}
		return true, err
	case 8: // message.channel_message_update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelMessageUpdate)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelMessageUpdate{msg}
		return true, err
	case 9: // message.channel_message_remove
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelMessageRemove)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelMessageRemove{msg}
		return true, err
	case 10: // message.channel_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChannelPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_ChannelPresenceEvent{msg}
		return true, err
	case 11: // message.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Error)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Error{msg}
		return true, err
	case 12: // message.match
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Match)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Match{msg}
		return true, err
	case 13: // message.match_create
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchCreate)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchCreate{msg}
		return true, err
	case 14: // message.match_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchData)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchData{msg}
		return true, err
	case 15: // message.match_data_send
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchDataSend)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchDataSend{msg}
		return true, err
	case 16: // message.match_join
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchJoin)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchJoin{msg}
		return true, err
	case 17: // message.match_leave
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchLeave)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchLeave{msg}
		return true, err
	case 18: // message.match_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchPresenceEvent{msg}
		return true, err
	case 19: // message.matchmaker_add
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchmakerAdd)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchmakerAdd{msg}
		return true, err
	case 20: // message.matchmaker_matched
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchmakerMatched)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchmakerMatched{msg}
		return true, err
	case 21: // message.matchmaker_remove
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchmakerRemove)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchmakerRemove{msg}
		return true, err
	case 22: // message.matchmaker_ticket
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchmakerTicket)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchmakerTicket{msg}
		return true, err
	case 23: // message.notifications
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Notifications)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Notifications{msg}
		return true, err
	case 24: // message.rpc
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(api.Rpc)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Rpc{msg}
		return true, err
	case 25: // message.status
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Status)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Status{msg}
		return true, err
	case 26: // message.status_follow
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatusFollow)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StatusFollow{msg}
		return true, err
	case 27: // message.status_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatusPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StatusPresenceEvent{msg}
		return true, err
	case 28: // message.status_unfollow
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatusUnfollow)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StatusUnfollow{msg}
		return true, err
	case 29: // message.status_update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatusUpdate)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StatusUpdate{msg}
		return true, err
	case 30: // message.stream_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamData)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StreamData{msg}
		return true, err
	case 31: // message.stream_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StreamPresenceEvent{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Envelope_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Envelope)
	// message
	switch x := m.Message.(type) {
	case *Envelope_Channel:
		s := proto.Size(x.Channel)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelJoin:
		s := proto.Size(x.ChannelJoin)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelLeave:
		s := proto.Size(x.ChannelLeave)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelMessage:
		s := proto.Size(x.ChannelMessage)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelMessageAck:
		s := proto.Size(x.ChannelMessageAck)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelMessageSend:
		s := proto.Size(x.ChannelMessageSend)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelMessageUpdate:
		s := proto.Size(x.ChannelMessageUpdate)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelMessageRemove:
		s := proto.Size(x.ChannelMessageRemove)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_ChannelPresenceEvent:
		s := proto.Size(x.ChannelPresenceEvent)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Error:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Match:
		s := proto.Size(x.Match)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchCreate:
		s := proto.Size(x.MatchCreate)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchData:
		s := proto.Size(x.MatchData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchDataSend:
		s := proto.Size(x.MatchDataSend)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchJoin:
		s := proto.Size(x.MatchJoin)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchLeave:
		s := proto.Size(x.MatchLeave)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchPresenceEvent:
		s := proto.Size(x.MatchPresenceEvent)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchmakerAdd:
		s := proto.Size(x.MatchmakerAdd)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchmakerMatched:
		s := proto.Size(x.MatchmakerMatched)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchmakerRemove:
		s := proto.Size(x.MatchmakerRemove)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchmakerTicket:
		s := proto.Size(x.MatchmakerTicket)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Notifications:
		s := proto.Size(x.Notifications)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Rpc:
		s := proto.Size(x.Rpc)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Status:
		s := proto.Size(x.Status)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StatusFollow:
		s := proto.Size(x.StatusFollow)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StatusPresenceEvent:
		s := proto.Size(x.StatusPresenceEvent)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StatusUnfollow:
		s := proto.Size(x.StatusUnfollow)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StatusUpdate:
		s := proto.Size(x.StatusUpdate)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StreamData:
		s := proto.Size(x.StreamData)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StreamPresenceEvent:
		s := proto.Size(x.StreamPresenceEvent)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A realtime chat channel.
type Channel struct {
	// The ID of the channel.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The users currently in the channel.
	Presences []*UserPresence `protobuf:"bytes,2,rep,name=presences,proto3" json:"presences,omitempty"`
	// A reference to the current user's presence in the channel.
	Self                 *UserPresence `protobuf:"bytes,3,opt,name=self,proto3" json:"self,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Channel) Reset()         { *m = Channel{} }
func (m *Channel) String() string { return proto.CompactTextString(m) }
func (*Channel) ProtoMessage()    {}
func (*Channel) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{1}
}

func (m *Channel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Channel.Unmarshal(m, b)
}
func (m *Channel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Channel.Marshal(b, m, deterministic)
}
func (m *Channel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Channel.Merge(m, src)
}
func (m *Channel) XXX_Size() int {
	return xxx_messageInfo_Channel.Size(m)
}
func (m *Channel) XXX_DiscardUnknown() {
	xxx_messageInfo_Channel.DiscardUnknown(m)
}

var xxx_messageInfo_Channel proto.InternalMessageInfo

func (m *Channel) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Channel) GetPresences() []*UserPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

func (m *Channel) GetSelf() *UserPresence {
	if m != nil {
		return m.Self
	}
	return nil
}

// Join operation for a realtime chat channel.
type ChannelJoin struct {
	// The user ID to DM with, group ID to chat with, or room channel name to join.
	Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// The type of the chat channel.
	Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	// Whether messages sent on this channel should be persistent.
	Persistence *wrappers.BoolValue `protobuf:"bytes,3,opt,name=persistence,proto3" json:"persistence,omitempty"`
	// Whether the user should appear in the channel's presence list and events.
	Hidden               *wrappers.BoolValue `protobuf:"bytes,4,opt,name=hidden,proto3" json:"hidden,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ChannelJoin) Reset()         { *m = ChannelJoin{} }
func (m *ChannelJoin) String() string { return proto.CompactTextString(m) }
func (*ChannelJoin) ProtoMessage()    {}
func (*ChannelJoin) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{2}
}

func (m *ChannelJoin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelJoin.Unmarshal(m, b)
}
func (m *ChannelJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelJoin.Marshal(b, m, deterministic)
}
func (m *ChannelJoin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelJoin.Merge(m, src)
}
func (m *ChannelJoin) XXX_Size() int {
	return xxx_messageInfo_ChannelJoin.Size(m)
}
func (m *ChannelJoin) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelJoin.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelJoin proto.InternalMessageInfo

func (m *ChannelJoin) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *ChannelJoin) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *ChannelJoin) GetPersistence() *wrappers.BoolValue {
	if m != nil {
		return m.Persistence
	}
	return nil
}

func (m *ChannelJoin) GetHidden() *wrappers.BoolValue {
	if m != nil {
		return m.Hidden
	}
	return nil
}

// Leave a realtime channel.
type ChannelLeave struct {
	// The ID of the channel to leave.
	ChannelId            string   `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelLeave) Reset()         { *m = ChannelLeave{} }
func (m *ChannelLeave) String() string { return proto.CompactTextString(m) }
func (*ChannelLeave) ProtoMessage()    {}
func (*ChannelLeave) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{3}
}

func (m *ChannelLeave) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelLeave.Unmarshal(m, b)
}
func (m *ChannelLeave) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelLeave.Marshal(b, m, deterministic)
}
func (m *ChannelLeave) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelLeave.Merge(m, src)
}
func (m *ChannelLeave) XXX_Size() int {
	return xxx_messageInfo_ChannelLeave.Size(m)
}
func (m *ChannelLeave) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelLeave.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelLeave proto.InternalMessageInfo

func (m *ChannelLeave) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

// A receipt reply from a channel message send operation.
type ChannelMessageAck struct {
	// The channel the message was sent to.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The unique ID assigned to the message.
	MessageId string `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// The code representing a message type or category.
	Code *wrappers.Int32Value `protobuf:"bytes,3,opt,name=code,proto3" json:"code,omitempty"`
	// Username of the message sender.
	Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"`
	// The UNIX time when the message was created.
	CreateTime *timestamp.Timestamp `protobuf:"bytes,5,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// The UNIX time when the message was last updated.
	UpdateTime *timestamp.Timestamp `protobuf:"bytes,6,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	// True if the message was persisted to the channel's history, false otherwise.
	Persistent           *wrappers.BoolValue `protobuf:"bytes,7,opt,name=persistent,proto3" json:"persistent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ChannelMessageAck) Reset()         { *m = ChannelMessageAck{} }
func (m *ChannelMessageAck) String() string { return proto.CompactTextString(m) }
func (*ChannelMessageAck) ProtoMessage()    {}
func (*ChannelMessageAck) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{4}
}

func (m *ChannelMessageAck) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelMessageAck.Unmarshal(m, b)
}
func (m *ChannelMessageAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelMessageAck.Marshal(b, m, deterministic)
}
func (m *ChannelMessageAck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelMessageAck.Merge(m, src)
}
func (m *ChannelMessageAck) XXX_Size() int {
	return xxx_messageInfo_ChannelMessageAck.Size(m)
}
func (m *ChannelMessageAck) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelMessageAck.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelMessageAck proto.InternalMessageInfo

func (m *ChannelMessageAck) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChannelMessageAck) GetMessageId() string {
	if m != nil {
		return m.MessageId
	}
	return ""
}

func (m *ChannelMessageAck) GetCode() *wrappers.Int32Value {
	if m != nil {
		return m.Code
	}
	return nil
}

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

func (m *ChannelMessageAck) GetCreateTime() *timestamp.Timestamp {
	if m != nil {
		return m.CreateTime
	}
	return nil
}

func (m *ChannelMessageAck) GetUpdateTime() *timestamp.Timestamp {
	if m != nil {
		return m.UpdateTime
	}
	return nil
}

func (m *ChannelMessageAck) GetPersistent() *wrappers.BoolValue {
	if m != nil {
		return m.Persistent
	}
	return nil
}

// Send a message to a realtime channel.
type ChannelMessageSend struct {
	// The channel to sent to.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// Message content.
	Content              string   `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelMessageSend) Reset()         { *m = ChannelMessageSend{} }
func (m *ChannelMessageSend) String() string { return proto.CompactTextString(m) }
func (*ChannelMessageSend) ProtoMessage()    {}
func (*ChannelMessageSend) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{5}
}

func (m *ChannelMessageSend) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelMessageSend.Unmarshal(m, b)
}
func (m *ChannelMessageSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelMessageSend.Marshal(b, m, deterministic)
}
func (m *ChannelMessageSend) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelMessageSend.Merge(m, src)
}
func (m *ChannelMessageSend) XXX_Size() int {
	return xxx_messageInfo_ChannelMessageSend.Size(m)
}
func (m *ChannelMessageSend) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelMessageSend.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelMessageSend proto.InternalMessageInfo

func (m *ChannelMessageSend) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChannelMessageSend) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

// Update a message previously sent to a realtime channel.
type ChannelMessageUpdate struct {
	// The channel the message was sent to.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The ID assigned to the message to update.
	MessageId string `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// New message content.
	Content              string   `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelMessageUpdate) Reset()         { *m = ChannelMessageUpdate{} }
func (m *ChannelMessageUpdate) String() string { return proto.CompactTextString(m) }
func (*ChannelMessageUpdate) ProtoMessage()    {}
func (*ChannelMessageUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{6}
}

func (m *ChannelMessageUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelMessageUpdate.Unmarshal(m, b)
}
func (m *ChannelMessageUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelMessageUpdate.Marshal(b, m, deterministic)
}
func (m *ChannelMessageUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelMessageUpdate.Merge(m, src)
}
func (m *ChannelMessageUpdate) XXX_Size() int {
	return xxx_messageInfo_ChannelMessageUpdate.Size(m)
}
func (m *ChannelMessageUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelMessageUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelMessageUpdate proto.InternalMessageInfo

func (m *ChannelMessageUpdate) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChannelMessageUpdate) GetMessageId() string {
	if m != nil {
		return m.MessageId
	}
	return ""
}

func (m *ChannelMessageUpdate) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

// Remove a message previously sent to a realtime channel.
type ChannelMessageRemove struct {
	// The channel the message was sent to.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The ID assigned to the message to update.
	MessageId            string   `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelMessageRemove) Reset()         { *m = ChannelMessageRemove{} }
func (m *ChannelMessageRemove) String() string { return proto.CompactTextString(m) }
func (*ChannelMessageRemove) ProtoMessage()    {}
func (*ChannelMessageRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{7}
}

func (m *ChannelMessageRemove) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelMessageRemove.Unmarshal(m, b)
}
func (m *ChannelMessageRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelMessageRemove.Marshal(b, m, deterministic)
}
func (m *ChannelMessageRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelMessageRemove.Merge(m, src)
}
func (m *ChannelMessageRemove) XXX_Size() int {
	return xxx_messageInfo_ChannelMessageRemove.Size(m)
}
func (m *ChannelMessageRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelMessageRemove.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelMessageRemove proto.InternalMessageInfo

func (m *ChannelMessageRemove) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChannelMessageRemove) GetMessageId() string {
	if m != nil {
		return m.MessageId
	}
	return ""
}

// A set of joins and leaves on a particular channel.
type ChannelPresenceEvent struct {
	// The channel identifier this event is for.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// Presences joining the channel as part of this event, if any.
	Joins []*UserPresence `protobuf:"bytes,2,rep,name=joins,proto3" json:"joins,omitempty"`
	// Presences leaving the channel as part of this event, if any.
	Leaves               []*UserPresence `protobuf:"bytes,3,rep,name=leaves,proto3" json:"leaves,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ChannelPresenceEvent) Reset()         { *m = ChannelPresenceEvent{} }
func (m *ChannelPresenceEvent) String() string { return proto.CompactTextString(m) }
func (*ChannelPresenceEvent) ProtoMessage()    {}
func (*ChannelPresenceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{8}
}

func (m *ChannelPresenceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelPresenceEvent.Unmarshal(m, b)
}
func (m *ChannelPresenceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelPresenceEvent.Marshal(b, m, deterministic)
}
func (m *ChannelPresenceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelPresenceEvent.Merge(m, src)
}
func (m *ChannelPresenceEvent) XXX_Size() int {
	return xxx_messageInfo_ChannelPresenceEvent.Size(m)
}
func (m *ChannelPresenceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelPresenceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelPresenceEvent proto.InternalMessageInfo

func (m *ChannelPresenceEvent) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChannelPresenceEvent) GetJoins() []*UserPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *ChannelPresenceEvent) GetLeaves() []*UserPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// A logical error which may occur on the server.
type Error struct {
	// The error code which should be one of "Error.Code" enums.
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// A message in English to help developers debug the response.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// Additional error details which may be different for each response.
	Context              map[string]string `protobuf:"bytes,3,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}
func (*Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{9}
}

func (m *Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Error.Unmarshal(m, b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Error.Marshal(b, m, deterministic)
}
func (m *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
	return xxx_messageInfo_Error.Size(m)
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *Error) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Error) GetContext() map[string]string {
	if m != nil {
		return m.Context
	}
	return nil
}

// A realtime match.
type Match struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	// True if it's an server-managed authoritative match, false otherwise.
	Authoritative bool `protobuf:"varint,2,opt,name=authoritative,proto3" json:"authoritative,omitempty"`
	// Match label, if any.
	Label *wrappers.StringValue `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty"`
	// The number of users currently in the match.
	Size int32 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	// The users currently in the match.
	Presences []*UserPresence `protobuf:"bytes,5,rep,name=presences,proto3" json:"presences,omitempty"`
	// A reference to the current user's presence in the match.
	Self                 *UserPresence `protobuf:"bytes,6,opt,name=self,proto3" json:"self,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Match) Reset()         { *m = Match{} }
func (m *Match) String() string { return proto.CompactTextString(m) }
func (*Match) ProtoMessage()    {}
func (*Match) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{10}
}

func (m *Match) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Match.Unmarshal(m, b)
}
func (m *Match) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Match.Marshal(b, m, deterministic)
}
func (m *Match) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Match.Merge(m, src)
}
func (m *Match) XXX_Size() int {
	return xxx_messageInfo_Match.Size(m)
}
func (m *Match) XXX_DiscardUnknown() {
	xxx_messageInfo_Match.DiscardUnknown(m)
}

var xxx_messageInfo_Match proto.InternalMessageInfo

func (m *Match) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *Match) GetAuthoritative() bool {
	if m != nil {
		return m.Authoritative
	}
	return false
}

func (m *Match) GetLabel() *wrappers.StringValue {
	if m != nil {
		return m.Label
	}
	return nil
}

func (m *Match) GetSize() int32 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *Match) GetPresences() []*UserPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

func (m *Match) GetSelf() *UserPresence {
	if m != nil {
		return m.Self
	}
	return nil
}

// Create a new realtime match.
type MatchCreate struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchCreate) Reset()         { *m = MatchCreate{} }
func (m *MatchCreate) String() string { return proto.CompactTextString(m) }
func (*MatchCreate) ProtoMessage()    {}
func (*MatchCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{11}
}

func (m *MatchCreate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchCreate.Unmarshal(m, b)
}
func (m *MatchCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchCreate.Marshal(b, m, deterministic)
}
func (m *MatchCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchCreate.Merge(m, src)
}
func (m *MatchCreate) XXX_Size() int {
	return xxx_messageInfo_MatchCreate.Size(m)
}
func (m *MatchCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchCreate.DiscardUnknown(m)
}

var xxx_messageInfo_MatchCreate proto.InternalMessageInfo

// Realtime match data received from the server.
type MatchData struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	// A reference to the user presence that sent this data, if any.
	Presence *UserPresence `protobuf:"bytes,2,opt,name=presence,proto3" json:"presence,omitempty"`
	// Op code value.
	OpCode int64 `protobuf:"varint,3,opt,name=op_code,json=opCode,proto3" json:"op_code,omitempty"`
	// Data payload, if any.
	Data                 []byte   `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchData) Reset()         { *m = MatchData{} }
func (m *MatchData) String() string { return proto.CompactTextString(m) }
func (*MatchData) ProtoMessage()    {}
func (*MatchData) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{12}
}

func (m *MatchData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchData.Unmarshal(m, b)
}
func (m *MatchData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchData.Marshal(b, m, deterministic)
}
func (m *MatchData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchData.Merge(m, src)
}
func (m *MatchData) XXX_Size() int {
	return xxx_messageInfo_MatchData.Size(m)
}
func (m *MatchData) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchData.DiscardUnknown(m)
}

var xxx_messageInfo_MatchData proto.InternalMessageInfo

func (m *MatchData) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchData) GetPresence() *UserPresence {
	if m != nil {
		return m.Presence
	}
	return nil
}

func (m *MatchData) GetOpCode() int64 {
	if m != nil {
		return m.OpCode
	}
	return 0
}

func (m *MatchData) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

// Send realtime match data to the server.
type MatchDataSend struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	// Op code value.
	OpCode int64 `protobuf:"varint,2,opt,name=op_code,json=opCode,proto3" json:"op_code,omitempty"`
	// Data payload, if any.
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// List of presences in the match to deliver to, if filtering is required. Otherwise deliver to everyone in the match.
	Presences            []*UserPresence `protobuf:"bytes,4,rep,name=presences,proto3" json:"presences,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *MatchDataSend) Reset()         { *m = MatchDataSend{} }
func (m *MatchDataSend) String() string { return proto.CompactTextString(m) }
func (*MatchDataSend) ProtoMessage()    {}
func (*MatchDataSend) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{13}
}

func (m *MatchDataSend) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchDataSend.Unmarshal(m, b)
}
func (m *MatchDataSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchDataSend.Marshal(b, m, deterministic)
}
func (m *MatchDataSend) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchDataSend.Merge(m, src)
}
func (m *MatchDataSend) XXX_Size() int {
	return xxx_messageInfo_MatchDataSend.Size(m)
}
func (m *MatchDataSend) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchDataSend.DiscardUnknown(m)
}

var xxx_messageInfo_MatchDataSend proto.InternalMessageInfo

func (m *MatchDataSend) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchDataSend) GetOpCode() int64 {
	if m != nil {
		return m.OpCode
	}
	return 0
}

func (m *MatchDataSend) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *MatchDataSend) GetPresences() []*UserPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

// Join an existing realtime match.
type MatchJoin struct {
	// Types that are valid to be assigned to Id:
	//	*MatchJoin_MatchId
	//	*MatchJoin_Token
	Id isMatchJoin_Id `protobuf_oneof:"id"`
	// An optional set of key-value metadata pairs to be passed to the match handler, if any.
	Metadata             map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *MatchJoin) Reset()         { *m = MatchJoin{} }
func (m *MatchJoin) String() string { return proto.CompactTextString(m) }
func (*MatchJoin) ProtoMessage()    {}
func (*MatchJoin) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{14}
}

func (m *MatchJoin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchJoin.Unmarshal(m, b)
}
func (m *MatchJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchJoin.Marshal(b, m, deterministic)
}
func (m *MatchJoin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchJoin.Merge(m, src)
}
func (m *MatchJoin) XXX_Size() int {
	return xxx_messageInfo_MatchJoin.Size(m)
}
func (m *MatchJoin) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchJoin.DiscardUnknown(m)
}

var xxx_messageInfo_MatchJoin proto.InternalMessageInfo

type isMatchJoin_Id interface {
	isMatchJoin_Id()
}

type MatchJoin_MatchId struct {
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3,oneof"`
}

type MatchJoin_Token struct {
	Token string `protobuf:"bytes,2,opt,name=token,proto3,oneof"`
}

func (*MatchJoin_MatchId) isMatchJoin_Id() {}

func (*MatchJoin_Token) isMatchJoin_Id() {}

func (m *MatchJoin) GetId() isMatchJoin_Id {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *MatchJoin) GetMatchId() string {
	if x, ok := m.GetId().(*MatchJoin_MatchId); ok {
		return x.MatchId
	}
	return ""
}

func (m *MatchJoin) GetToken() string {
	if x, ok := m.GetId().(*MatchJoin_Token); ok {
		return x.Token
	}
	return ""
}

func (m *MatchJoin) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*MatchJoin) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _MatchJoin_OneofMarshaler, _MatchJoin_OneofUnmarshaler, _MatchJoin_OneofSizer, []interface{}{
		(*MatchJoin_MatchId)(nil),
		(*MatchJoin_Token)(nil),
	}
}

func _MatchJoin_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*MatchJoin)
	// id
	switch x := m.Id.(type) {
	case *MatchJoin_MatchId:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.MatchId)
	case *MatchJoin_Token:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Token)
	case nil:
	default:
		return fmt.Errorf("MatchJoin.Id has unexpected type %T", x)
	}
	return nil
}

func _MatchJoin_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*MatchJoin)
	switch tag {
	case 1: // id.match_id
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchJoin_MatchId{x}
		return true, err
	case 2: // id.token
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchJoin_Token{x}
		return true, err
	default:
		return false, nil
	}
}

func _MatchJoin_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*MatchJoin)
	// id
	switch x := m.Id.(type) {
	case *MatchJoin_MatchId:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.MatchId)))
		n += len(x.MatchId)
	case *MatchJoin_Token:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Token)))
		n += len(x.Token)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Leave a realtime match.
type MatchLeave struct {
	// The match unique ID.
	MatchId              string   `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchLeave) Reset()         { *m = MatchLeave{} }
func (m *MatchLeave) String() string { return proto.CompactTextString(m) }
func (*MatchLeave) ProtoMessage()    {}
func (*MatchLeave) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{15}
}

func (m *MatchLeave) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchLeave.Unmarshal(m, b)
}
func (m *MatchLeave) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchLeave.Marshal(b, m, deterministic)
}
func (m *MatchLeave) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchLeave.Merge(m, src)
}
func (m *MatchLeave) XXX_Size() int {
	return xxx_messageInfo_MatchLeave.Size(m)
}
func (m *MatchLeave) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchLeave.DiscardUnknown(m)
}

var xxx_messageInfo_MatchLeave proto.InternalMessageInfo

func (m *MatchLeave) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

// A set of joins and leaves on a particular realtime match.
type MatchPresenceEvent struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	// User presences that have just joined the match.
	Joins []*UserPresence `protobuf:"bytes,2,rep,name=joins,proto3" json:"joins,omitempty"`
	// User presences that have just left the match.
	Leaves               []*UserPresence `protobuf:"bytes,3,rep,name=leaves,proto3" json:"leaves,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *MatchPresenceEvent) Reset()         { *m = MatchPresenceEvent{} }
func (m *MatchPresenceEvent) String() string { return proto.CompactTextString(m) }
func (*MatchPresenceEvent) ProtoMessage()    {}
func (*MatchPresenceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{16}
}

func (m *MatchPresenceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchPresenceEvent.Unmarshal(m, b)
}
func (m *MatchPresenceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchPresenceEvent.Marshal(b, m, deterministic)
}
func (m *MatchPresenceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchPresenceEvent.Merge(m, src)
}
func (m *MatchPresenceEvent) XXX_Size() int {
	return xxx_messageInfo_MatchPresenceEvent.Size(m)
}
func (m *MatchPresenceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchPresenceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_MatchPresenceEvent proto.InternalMessageInfo

func (m *MatchPresenceEvent) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchPresenceEvent) GetJoins() []*UserPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *MatchPresenceEvent) GetLeaves() []*UserPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// Start a new matchmaking process.
type MatchmakerAdd struct {
	// Minimum total user count to match together.
	MinCount int32 `protobuf:"varint,1,opt,name=min_count,json=minCount,proto3" json:"min_count,omitempty"`
	// Maximum total user count to match together.
	MaxCount int32 `protobuf:"varint,2,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	// Filter query used to identify suitable users.
	Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"`
	// String properties.
	StringProperties map[string]string `protobuf:"bytes,4,rep,name=string_properties,json=stringProperties,proto3" json:"string_properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Numeric properties.
	NumericProperties    map[string]float64 `protobuf:"bytes,5,rep,name=numeric_properties,json=numericProperties,proto3" json:"numeric_properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *MatchmakerAdd) Reset()         { *m = MatchmakerAdd{} }
func (m *MatchmakerAdd) String() string { return proto.CompactTextString(m) }
func (*MatchmakerAdd) ProtoMessage()    {}
func (*MatchmakerAdd) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{17}
}

func (m *MatchmakerAdd) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchmakerAdd.Unmarshal(m, b)
}
func (m *MatchmakerAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchmakerAdd.Marshal(b, m, deterministic)
}
func (m *MatchmakerAdd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchmakerAdd.Merge(m, src)
}
func (m *MatchmakerAdd) XXX_Size() int {
	return xxx_messageInfo_MatchmakerAdd.Size(m)
}
func (m *MatchmakerAdd) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchmakerAdd.DiscardUnknown(m)
}

var xxx_messageInfo_MatchmakerAdd proto.InternalMessageInfo

func (m *MatchmakerAdd) GetMinCount() int32 {
	if m != nil {
		return m.MinCount
	}
	return 0
}

func (m *MatchmakerAdd) GetMaxCount() int32 {
	if m != nil {
		return m.MaxCount
	}
	return 0
}

func (m *MatchmakerAdd) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

func (m *MatchmakerAdd) GetStringProperties() map[string]string {
	if m != nil {
		return m.StringProperties
	}
	return nil
}

func (m *MatchmakerAdd) GetNumericProperties() map[string]float64 {
	if m != nil {
		return m.NumericProperties
	}
	return nil
}

// A successful matchmaking result.
type MatchmakerMatched struct {
	// The matchmaking ticket that has completed.
	Ticket string `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
	// The match token or match ID to join.
	//
	// Types that are valid to be assigned to Id:
	//	*MatchmakerMatched_MatchId
	//	*MatchmakerMatched_Token
	Id isMatchmakerMatched_Id `protobuf_oneof:"id"`
	// The users that have been matched together, and information about their matchmaking data.
	Users []*MatchmakerMatched_MatchmakerUser `protobuf:"bytes,4,rep,name=users,proto3" json:"users,omitempty"`
	// A reference to the current user and their properties.
	Self                 *MatchmakerMatched_MatchmakerUser `protobuf:"bytes,5,opt,name=self,proto3" json:"self,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *MatchmakerMatched) Reset()         { *m = MatchmakerMatched{} }
func (m *MatchmakerMatched) String() string { return proto.CompactTextString(m) }
func (*MatchmakerMatched) ProtoMessage()    {}
func (*MatchmakerMatched) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{18}
}

func (m *MatchmakerMatched) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchmakerMatched.Unmarshal(m, b)
}
func (m *MatchmakerMatched) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchmakerMatched.Marshal(b, m, deterministic)
}
func (m *MatchmakerMatched) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchmakerMatched.Merge(m, src)
}
func (m *MatchmakerMatched) XXX_Size() int {
	return xxx_messageInfo_MatchmakerMatched.Size(m)
}
func (m *MatchmakerMatched) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchmakerMatched.DiscardUnknown(m)
}

var xxx_messageInfo_MatchmakerMatched proto.InternalMessageInfo

func (m *MatchmakerMatched) GetTicket() string {
	if m != nil {
		return m.Ticket
	}
	return ""
}

type isMatchmakerMatched_Id interface {
	isMatchmakerMatched_Id()
}

type MatchmakerMatched_MatchId struct {
	MatchId string `protobuf:"bytes,2,opt,name=match_id,json=matchId,proto3,oneof"`
}

type MatchmakerMatched_Token struct {
	Token string `protobuf:"bytes,3,opt,name=token,proto3,oneof"`
}

func (*MatchmakerMatched_MatchId) isMatchmakerMatched_Id() {}

func (*MatchmakerMatched_Token) isMatchmakerMatched_Id() {}

func (m *MatchmakerMatched) GetId() isMatchmakerMatched_Id {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *MatchmakerMatched) GetMatchId() string {
	if x, ok := m.GetId().(*MatchmakerMatched_MatchId); ok {
		return x.MatchId
	}
	return ""
}

func (m *MatchmakerMatched) GetToken() string {
	if x, ok := m.GetId().(*MatchmakerMatched_Token); ok {
		return x.Token
	}
	return ""
}

func (m *MatchmakerMatched) GetUsers() []*MatchmakerMatched_MatchmakerUser {
	if m != nil {
		return m.Users
	}
	return nil
}

func (m *MatchmakerMatched) GetSelf() *MatchmakerMatched_MatchmakerUser {
	if m != nil {
		return m.Self
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*MatchmakerMatched) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _MatchmakerMatched_OneofMarshaler, _MatchmakerMatched_OneofUnmarshaler, _MatchmakerMatched_OneofSizer, []interface{}{
		(*MatchmakerMatched_MatchId)(nil),
		(*MatchmakerMatched_Token)(nil),
	}
}

func _MatchmakerMatched_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*MatchmakerMatched)
	// id
	switch x := m.Id.(type) {
	case *MatchmakerMatched_MatchId:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.MatchId)
	case *MatchmakerMatched_Token:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Token)
	case nil:
	default:
		return fmt.Errorf("MatchmakerMatched.Id has unexpected type %T", x)
	}
	return nil
}

func _MatchmakerMatched_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*MatchmakerMatched)
	switch tag {
	case 2: // id.match_id
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchmakerMatched_MatchId{x}
		return true, err
	case 3: // id.token
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchmakerMatched_Token{x}
		return true, err
	default:
		return false, nil
	}
}

func _MatchmakerMatched_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*MatchmakerMatched)
	// id
	switch x := m.Id.(type) {
	case *MatchmakerMatched_MatchId:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.MatchId)))
		n += len(x.MatchId)
	case *MatchmakerMatched_Token:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Token)))
		n += len(x.Token)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type MatchmakerMatched_MatchmakerUser struct {
	// User info.
	Presence *UserPresence `protobuf:"bytes,1,opt,name=presence,proto3" json:"presence,omitempty"`
	// String properties.
	StringProperties map[string]string `protobuf:"bytes,5,rep,name=string_properties,json=stringProperties,proto3" json:"string_properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Numeric properties.
	NumericProperties    map[string]float64 `protobuf:"bytes,6,rep,name=numeric_properties,json=numericProperties,proto3" json:"numeric_properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *MatchmakerMatched_MatchmakerUser) Reset()         { *m = MatchmakerMatched_MatchmakerUser{} }
func (m *MatchmakerMatched_MatchmakerUser) String() string { return proto.CompactTextString(m) }
func (*MatchmakerMatched_MatchmakerUser) ProtoMessage()    {}
func (*MatchmakerMatched_MatchmakerUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{18, 0}
}

func (m *MatchmakerMatched_MatchmakerUser) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchmakerMatched_MatchmakerUser.Unmarshal(m, b)
}
func (m *MatchmakerMatched_MatchmakerUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchmakerMatched_MatchmakerUser.Marshal(b, m, deterministic)
}
func (m *MatchmakerMatched_MatchmakerUser) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchmakerMatched_MatchmakerUser.Merge(m, src)
}
func (m *MatchmakerMatched_MatchmakerUser) XXX_Size() int {
	return xxx_messageInfo_MatchmakerMatched_MatchmakerUser.Size(m)
}
func (m *MatchmakerMatched_MatchmakerUser) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchmakerMatched_MatchmakerUser.DiscardUnknown(m)
}

var xxx_messageInfo_MatchmakerMatched_MatchmakerUser proto.InternalMessageInfo

func (m *MatchmakerMatched_MatchmakerUser) GetPresence() *UserPresence {
	if m != nil {
		return m.Presence
	}
	return nil
}

func (m *MatchmakerMatched_MatchmakerUser) GetStringProperties() map[string]string {
	if m != nil {
		return m.StringProperties
	}
	return nil
}

func (m *MatchmakerMatched_MatchmakerUser) GetNumericProperties() map[string]float64 {
	if m != nil {
		return m.NumericProperties
	}
	return nil
}

// Cancel an existing ongoing matchmaking process.
type MatchmakerRemove struct {
	// The ticket to cancel.
	Ticket               string   `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchmakerRemove) Reset()         { *m = MatchmakerRemove{} }
func (m *MatchmakerRemove) String() string { return proto.CompactTextString(m) }
func (*MatchmakerRemove) ProtoMessage()    {}
func (*MatchmakerRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{19}
}

func (m *MatchmakerRemove) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchmakerRemove.Unmarshal(m, b)
}
func (m *MatchmakerRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchmakerRemove.Marshal(b, m, deterministic)
}
func (m *MatchmakerRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchmakerRemove.Merge(m, src)
}
func (m *MatchmakerRemove) XXX_Size() int {
	return xxx_messageInfo_MatchmakerRemove.Size(m)
}
func (m *MatchmakerRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchmakerRemove.DiscardUnknown(m)
}

var xxx_messageInfo_MatchmakerRemove proto.InternalMessageInfo

func (m *MatchmakerRemove) GetTicket() string {
	if m != nil {
		return m.Ticket
	}
	return ""
}

// A ticket representing a new matchmaking process.
type MatchmakerTicket struct {
	// The ticket that can be used to cancel matchmaking.
	Ticket               string   `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchmakerTicket) Reset()         { *m = MatchmakerTicket{} }
func (m *MatchmakerTicket) String() string { return proto.CompactTextString(m) }
func (*MatchmakerTicket) ProtoMessage()    {}
func (*MatchmakerTicket) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{20}
}

func (m *MatchmakerTicket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchmakerTicket.Unmarshal(m, b)
}
func (m *MatchmakerTicket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchmakerTicket.Marshal(b, m, deterministic)
}
func (m *MatchmakerTicket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchmakerTicket.Merge(m, src)
}
func (m *MatchmakerTicket) XXX_Size() int {
	return xxx_messageInfo_MatchmakerTicket.Size(m)
}
func (m *MatchmakerTicket) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchmakerTicket.DiscardUnknown(m)
}

var xxx_messageInfo_MatchmakerTicket proto.InternalMessageInfo

func (m *MatchmakerTicket) GetTicket() string {
	if m != nil {
		return m.Ticket
	}
	return ""
}

// A collection of zero or more notifications.
type Notifications struct {
	// Collection of notifications.
	Notifications        []*api.Notification `protobuf:"bytes,1,rep,name=notifications,proto3" json:"notifications,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *Notifications) Reset()         { *m = Notifications{} }
func (m *Notifications) String() string { return proto.CompactTextString(m) }
func (*Notifications) ProtoMessage()    {}
func (*Notifications) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{21}
}

func (m *Notifications) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Notifications.Unmarshal(m, b)
}
func (m *Notifications) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Notifications.Marshal(b, m, deterministic)
}
func (m *Notifications) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Notifications.Merge(m, src)
}
func (m *Notifications) XXX_Size() int {
	return xxx_messageInfo_Notifications.Size(m)
}
func (m *Notifications) XXX_DiscardUnknown() {
	xxx_messageInfo_Notifications.DiscardUnknown(m)
}

var xxx_messageInfo_Notifications proto.InternalMessageInfo

func (m *Notifications) GetNotifications() []*api.Notification {
	if m != nil {
		return m.Notifications
	}
	return nil
}

// A snapshot of statuses for some set of users.
type Status struct {
	// User statuses.
	Presences            []*UserPresence `protobuf:"bytes,1,rep,name=presences,proto3" json:"presences,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Status) Reset()         { *m = Status{} }
func (m *Status) String() string { return proto.CompactTextString(m) }
func (*Status) ProtoMessage()    {}
func (*Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{22}
}

func (m *Status) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Status.Unmarshal(m, b)
}
func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Status.Marshal(b, m, deterministic)
}
func (m *Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Status.Merge(m, src)
}
func (m *Status) XXX_Size() int {
	return xxx_messageInfo_Status.Size(m)
}
func (m *Status) XXX_DiscardUnknown() {
	xxx_messageInfo_Status.DiscardUnknown(m)
}

var xxx_messageInfo_Status proto.InternalMessageInfo

func (m *Status) GetPresences() []*UserPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

// Start receiving status updates for some set of users.
type StatusFollow struct {
	// Users to follow.
	UserIds              []string `protobuf:"bytes,1,rep,name=user_ids,json=userIds,proto3" json:"user_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StatusFollow) Reset()         { *m = StatusFollow{} }
func (m *StatusFollow) String() string { return proto.CompactTextString(m) }
func (*StatusFollow) ProtoMessage()    {}
func (*StatusFollow) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{23}
}

func (m *StatusFollow) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatusFollow.Unmarshal(m, b)
}
func (m *StatusFollow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatusFollow.Marshal(b, m, deterministic)
}
func (m *StatusFollow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatusFollow.Merge(m, src)
}
func (m *StatusFollow) XXX_Size() int {
	return xxx_messageInfo_StatusFollow.Size(m)
}
func (m *StatusFollow) XXX_DiscardUnknown() {
	xxx_messageInfo_StatusFollow.DiscardUnknown(m)
}

var xxx_messageInfo_StatusFollow proto.InternalMessageInfo

func (m *StatusFollow) GetUserIds() []string {
	if m != nil {
		return m.UserIds
	}
	return nil
}

// A batch of status updates for a given user.
type StatusPresenceEvent struct {
	// New statuses for the user.
	Joins []*UserPresence `protobuf:"bytes,2,rep,name=joins,proto3" json:"joins,omitempty"`
	// Previous statuses for the user.
	Leaves               []*UserPresence `protobuf:"bytes,3,rep,name=leaves,proto3" json:"leaves,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *StatusPresenceEvent) Reset()         { *m = StatusPresenceEvent{} }
func (m *StatusPresenceEvent) String() string { return proto.CompactTextString(m) }
func (*StatusPresenceEvent) ProtoMessage()    {}
func (*StatusPresenceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{24}
}

func (m *StatusPresenceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatusPresenceEvent.Unmarshal(m, b)
}
func (m *StatusPresenceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatusPresenceEvent.Marshal(b, m, deterministic)
}
func (m *StatusPresenceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatusPresenceEvent.Merge(m, src)
}
func (m *StatusPresenceEvent) XXX_Size() int {
	return xxx_messageInfo_StatusPresenceEvent.Size(m)
}
func (m *StatusPresenceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_StatusPresenceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_StatusPresenceEvent proto.InternalMessageInfo

func (m *StatusPresenceEvent) GetJoins() []*UserPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *StatusPresenceEvent) GetLeaves() []*UserPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// Stop receiving status updates for some set of users.
type StatusUnfollow struct {
	// Users to unfollow.
	UserIds              []string `protobuf:"bytes,1,rep,name=user_ids,json=userIds,proto3" json:"user_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StatusUnfollow) Reset()         { *m = StatusUnfollow{} }
func (m *StatusUnfollow) String() string { return proto.CompactTextString(m) }
func (*StatusUnfollow) ProtoMessage()    {}
func (*StatusUnfollow) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{25}
}

func (m *StatusUnfollow) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatusUnfollow.Unmarshal(m, b)
}
func (m *StatusUnfollow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatusUnfollow.Marshal(b, m, deterministic)
}
func (m *StatusUnfollow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatusUnfollow.Merge(m, src)
}
func (m *StatusUnfollow) XXX_Size() int {
	return xxx_messageInfo_StatusUnfollow.Size(m)
}
func (m *StatusUnfollow) XXX_DiscardUnknown() {
	xxx_messageInfo_StatusUnfollow.DiscardUnknown(m)
}

var xxx_messageInfo_StatusUnfollow proto.InternalMessageInfo

func (m *StatusUnfollow) GetUserIds() []string {
	if m != nil {
		return m.UserIds
	}
	return nil
}

// Set the user's own status.
type StatusUpdate struct {
	// Status string to set, if not present the user will appear offline.
	Status               *wrappers.StringValue `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *StatusUpdate) Reset()         { *m = StatusUpdate{} }
func (m *StatusUpdate) String() string { return proto.CompactTextString(m) }
func (*StatusUpdate) ProtoMessage()    {}
func (*StatusUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{26}
}

func (m *StatusUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatusUpdate.Unmarshal(m, b)
}
func (m *StatusUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatusUpdate.Marshal(b, m, deterministic)
}
func (m *StatusUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatusUpdate.Merge(m, src)
}
func (m *StatusUpdate) XXX_Size() int {
	return xxx_messageInfo_StatusUpdate.Size(m)
}
func (m *StatusUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_StatusUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_StatusUpdate proto.InternalMessageInfo

func (m *StatusUpdate) GetStatus() *wrappers.StringValue {
	if m != nil {
		return m.Status
	}
	return nil
}

// Represents identifying information for a stream.
type Stream struct {
	// Mode identifies the type of stream.
	Mode int32 `protobuf:"varint,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// Subject is the primary identifier, if any.
	Subject string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
	// Subcontext is a secondary identifier, if any.
	Subcontext string `protobuf:"bytes,3,opt,name=subcontext,proto3" json:"subcontext,omitempty"`
	// The label is an arbitrary identifying string, if the stream has one.
	Label                string   `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Stream) Reset()         { *m = Stream{} }
func (m *Stream) String() string { return proto.CompactTextString(m) }
func (*Stream) ProtoMessage()    {}
func (*Stream) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{27}
}

func (m *Stream) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Stream.Unmarshal(m, b)
}
func (m *Stream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Stream.Marshal(b, m, deterministic)
}
func (m *Stream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Stream.Merge(m, src)
}
func (m *Stream) XXX_Size() int {
	return xxx_messageInfo_Stream.Size(m)
}
func (m *Stream) XXX_DiscardUnknown() {
	xxx_messageInfo_Stream.DiscardUnknown(m)
}

var xxx_messageInfo_Stream proto.InternalMessageInfo

func (m *Stream) GetMode() int32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *Stream) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *Stream) GetSubcontext() string {
	if m != nil {
		return m.Subcontext
	}
	return ""
}

func (m *Stream) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

// A data message delivered over a stream.
type StreamData struct {
	// The stream this data message relates to.
	Stream *Stream `protobuf:"bytes,1,opt,name=stream,proto3" json:"stream,omitempty"`
	// The sender, if any.
	Sender *UserPresence `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	// Arbitrary contents of the data message.
	Data                 string   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamData) Reset()         { *m = StreamData{} }
func (m *StreamData) String() string { return proto.CompactTextString(m) }
func (*StreamData) ProtoMessage()    {}
func (*StreamData) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{28}
}

func (m *StreamData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamData.Unmarshal(m, b)
}
func (m *StreamData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamData.Marshal(b, m, deterministic)
}
func (m *StreamData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamData.Merge(m, src)
}
func (m *StreamData) XXX_Size() int {
	return xxx_messageInfo_StreamData.Size(m)
}
func (m *StreamData) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamData.DiscardUnknown(m)
}

var xxx_messageInfo_StreamData proto.InternalMessageInfo

func (m *StreamData) GetStream() *Stream {
	if m != nil {
		return m.Stream
	}
	return nil
}

func (m *StreamData) GetSender() *UserPresence {
	if m != nil {
		return m.Sender
	}
	return nil
}

func (m *StreamData) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

// A set of joins and leaves on a particular stream.
type StreamPresenceEvent struct {
	// The stream this event relates to.
	Stream *Stream `protobuf:"bytes,1,opt,name=stream,proto3" json:"stream,omitempty"`
	// Presences joining the stream as part of this event, if any.
	Joins []*UserPresence `protobuf:"bytes,2,rep,name=joins,proto3" json:"joins,omitempty"`
	// Presences leaving the stream as part of this event, if any.
	Leaves               []*UserPresence `protobuf:"bytes,3,rep,name=leaves,proto3" json:"leaves,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *StreamPresenceEvent) Reset()         { *m = StreamPresenceEvent{} }
func (m *StreamPresenceEvent) String() string { return proto.CompactTextString(m) }
func (*StreamPresenceEvent) ProtoMessage()    {}
func (*StreamPresenceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{29}
}

func (m *StreamPresenceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamPresenceEvent.Unmarshal(m, b)
}
func (m *StreamPresenceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamPresenceEvent.Marshal(b, m, deterministic)
}
func (m *StreamPresenceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamPresenceEvent.Merge(m, src)
}
func (m *StreamPresenceEvent) XXX_Size() int {
	return xxx_messageInfo_StreamPresenceEvent.Size(m)
}
func (m *StreamPresenceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamPresenceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_StreamPresenceEvent proto.InternalMessageInfo

func (m *StreamPresenceEvent) GetStream() *Stream {
	if m != nil {
		return m.Stream
	}
	return nil
}

func (m *StreamPresenceEvent) GetJoins() []*UserPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *StreamPresenceEvent) GetLeaves() []*UserPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// A user session associated to a stream, usually through a list operation or a join/leave event.
type UserPresence struct {
	// The user this presence belongs to.
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// A unique session ID identifying the particular connection, because the user may have many.
	SessionId string `protobuf:"bytes,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// The username for display purposes.
	Username string `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	// Whether this presence generates persistent data/messages, if applicable for the stream type.
	Persistence bool `protobuf:"varint,4,opt,name=persistence,proto3" json:"persistence,omitempty"`
	// A user-set status message for this stream, if applicable.
	Status               *wrappers.StringValue `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *UserPresence) Reset()         { *m = UserPresence{} }
func (m *UserPresence) String() string { return proto.CompactTextString(m) }
func (*UserPresence) ProtoMessage()    {}
func (*UserPresence) Descriptor() ([]byte, []int) {
	return fileDescriptor_0163624496220f8c, []int{30}
}

func (m *UserPresence) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UserPresence.Unmarshal(m, b)
}
func (m *UserPresence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UserPresence.Marshal(b, m, deterministic)
}
func (m *UserPresence) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UserPresence.Merge(m, src)
}
func (m *UserPresence) XXX_Size() int {
	return xxx_messageInfo_UserPresence.Size(m)
}
func (m *UserPresence) XXX_DiscardUnknown() {
	xxx_messageInfo_UserPresence.DiscardUnknown(m)
}

var xxx_messageInfo_UserPresence proto.InternalMessageInfo

func (m *UserPresence) GetUserId() string {
	if m != nil {
		return m.UserId
	}
	return ""
}

func (m *UserPresence) GetSessionId() string {
	if m != nil {
		return m.SessionId
	}
	return ""
}

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

func (m *UserPresence) GetPersistence() bool {
	if m != nil {
		return m.Persistence
	}
	return false
}

func (m *UserPresence) GetStatus() *wrappers.StringValue {
	if m != nil {
		return m.Status
	}
	return nil
}

func init() {
	proto.RegisterEnum("nakama.realtime.ChannelJoin_Type", ChannelJoin_Type_name, ChannelJoin_Type_value)
	proto.RegisterEnum("nakama.realtime.Error_Code", Error_Code_name, Error_Code_value)
	proto.RegisterType((*Envelope)(nil), "nakama.realtime.Envelope")
	proto.RegisterType((*Channel)(nil), "nakama.realtime.Channel")
	proto.RegisterType((*ChannelJoin)(nil), "nakama.realtime.ChannelJoin")
	proto.RegisterType((*ChannelLeave)(nil), "nakama.realtime.ChannelLeave")
	proto.RegisterType((*ChannelMessageAck)(nil), "nakama.realtime.ChannelMessageAck")
	proto.RegisterType((*ChannelMessageSend)(nil), "nakama.realtime.ChannelMessageSend")
	proto.RegisterType((*ChannelMessageUpdate)(nil), "nakama.realtime.ChannelMessageUpdate")
	proto.RegisterType((*ChannelMessageRemove)(nil), "nakama.realtime.ChannelMessageRemove")
	proto.RegisterType((*ChannelPresenceEvent)(nil), "nakama.realtime.ChannelPresenceEvent")
	proto.RegisterType((*Error)(nil), "nakama.realtime.Error")
	proto.RegisterMapType((map[string]string)(nil), "nakama.realtime.Error.ContextEntry")
	proto.RegisterType((*Match)(nil), "nakama.realtime.Match")
	proto.RegisterType((*MatchCreate)(nil), "nakama.realtime.MatchCreate")
	proto.RegisterType((*MatchData)(nil), "nakama.realtime.MatchData")
	proto.RegisterType((*MatchDataSend)(nil), "nakama.realtime.MatchDataSend")
	proto.RegisterType((*MatchJoin)(nil), "nakama.realtime.MatchJoin")
	proto.RegisterMapType((map[string]string)(nil), "nakama.realtime.MatchJoin.MetadataEntry")
	proto.RegisterType((*MatchLeave)(nil), "nakama.realtime.MatchLeave")
	proto.RegisterType((*MatchPresenceEvent)(nil), "nakama.realtime.MatchPresenceEvent")
	proto.RegisterType((*MatchmakerAdd)(nil), "nakama.realtime.MatchmakerAdd")
	proto.RegisterMapType((map[string]float64)(nil), "nakama.realtime.MatchmakerAdd.NumericPropertiesEntry")
	proto.RegisterMapType((map[string]string)(nil), "nakama.realtime.MatchmakerAdd.StringPropertiesEntry")
	proto.RegisterType((*MatchmakerMatched)(nil), "nakama.realtime.MatchmakerMatched")
	proto.RegisterType((*MatchmakerMatched_MatchmakerUser)(nil), "nakama.realtime.MatchmakerMatched.MatchmakerUser")
	proto.RegisterMapType((map[string]float64)(nil), "nakama.realtime.MatchmakerMatched.MatchmakerUser.NumericPropertiesEntry")
	proto.RegisterMapType((map[string]string)(nil), "nakama.realtime.MatchmakerMatched.MatchmakerUser.StringPropertiesEntry")
	proto.RegisterType((*MatchmakerRemove)(nil), "nakama.realtime.MatchmakerRemove")
	proto.RegisterType((*MatchmakerTicket)(nil), "nakama.realtime.MatchmakerTicket")
	proto.RegisterType((*Notifications)(nil), "nakama.realtime.Notifications")
	proto.RegisterType((*Status)(nil), "nakama.realtime.Status")
	proto.RegisterType((*StatusFollow)(nil), "nakama.realtime.StatusFollow")
	proto.RegisterType((*StatusPresenceEvent)(nil), "nakama.realtime.StatusPresenceEvent")
	proto.RegisterType((*StatusUnfollow)(nil), "nakama.realtime.StatusUnfollow")
	proto.RegisterType((*StatusUpdate)(nil), "nakama.realtime.StatusUpdate")
	proto.RegisterType((*Stream)(nil), "nakama.realtime.Stream")
	proto.RegisterType((*StreamData)(nil), "nakama.realtime.StreamData")
	proto.RegisterType((*StreamPresenceEvent)(nil), "nakama.realtime.StreamPresenceEvent")
	proto.RegisterType((*UserPresence)(nil), "nakama.realtime.UserPresence")
}

func init() { proto.RegisterFile("rtapi/realtime.proto", fileDescriptor_0163624496220f8c) }

var fileDescriptor_0163624496220f8c = []byte{
	// 2153 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x73, 0xe3, 0x48,
	0x15, 0xb7, 0xfc, 0x95, 0xf8, 0x25, 0x4e, 0x9c, 0x8e, 0x27, 0xd1, 0x3a, 0x3b, 0x99, 0x41, 0xb3,
	0x14, 0xc3, 0x52, 0x38, 0x35, 0x1f, 0x5b, 0x05, 0x33, 0x30, 0x55, 0x89, 0xad, 0xc4, 0x1e, 0xd6,
	0x1f, 0x25, 0xdb, 0x2c, 0x3b, 0x55, 0x94, 0x4a, 0x91, 0x7a, 0x12, 0x6d, 0x2c, 0xc9, 0x48, 0x72,
	0x66, 0xc2, 0x09, 0x6e, 0x70, 0xe1, 0xc4, 0x8d, 0x13, 0x1c, 0xe1, 0x06, 0x37, 0x0e, 0xdc, 0x38,
	0x70, 0xe7, 0x2f, 0xe1, 0xcc, 0x81, 0xea, 0x0f, 0xc9, 0x92, 0x6c, 0xd9, 0xc9, 0x6e, 0xd5, 0x54,
	0x71, 0x73, 0xbf, 0xfe, 0xbd, 0x5f, 0xb7, 0x5e, 0xbf, 0xf7, 0xfa, 0xbd, 0x36, 0x54, 0x5d, 0x5f,
	0x9b, 0x98, 0x47, 0x2e, 0xd6, 0xc6, 0xbe, 0x69, 0xe1, 0xfa, 0xc4, 0x75, 0x7c, 0x07, 0x6d, 0xdb,
	0xda, 0x95, 0x66, 0x69, 0xf5, 0x40, 0x5c, 0x7b, 0x70, 0xe1, 0x38, 0x17, 0x63, 0x7c, 0x44, 0xa7,
	0xcf, 0xa7, 0x6f, 0x8f, 0x88, 0xd4, 0xf3, 0x35, 0x6b, 0xc2, 0x34, 0x6a, 0x87, 0x49, 0xc0, 0x3b,
	0x57, 0x9b, 0x4c, 0xb0, 0xeb, 0xf1, 0xf9, 0x4f, 0x2f, 0x4c, 0xff, 0x72, 0x7a, 0x5e, 0xd7, 0x1d,
	0xeb, 0xe8, 0x12, 0xbb, 0x8e, 0xa9, 0x8f, 0xb5, 0x73, 0xef, 0x88, 0xad, 0x73, 0x44, 0xb6, 0xa0,
	0x4d, 0x4c, 0x86, 0x95, 0xfe, 0xb2, 0x03, 0xeb, 0xb2, 0x7d, 0x8d, 0xc7, 0xce, 0x04, 0xa3, 0x0a,
	0xe4, 0x74, 0xd3, 0x10, 0x85, 0x87, 0xc2, 0xe3, 0x92, 0x42, 0x7e, 0xa2, 0xe7, 0xb0, 0xa6, 0x5f,
	0x6a, 0xb6, 0x8d, 0xc7, 0x62, 0xf6, 0xa1, 0xf0, 0x78, 0xe3, 0xa9, 0x58, 0x4f, 0x6c, 0xb7, 0xde,
	0x60, 0xf3, 0xad, 0x8c, 0x12, 0x40, 0xd1, 0x31, 0x6c, 0xf2, 0x9f, 0xea, 0x57, 0x8e, 0x69, 0x8b,
	0x39, 0xaa, 0xfa, 0x71, 0x9a, 0xea, 0x6b, 0xc7, 0xb4, 0x5b, 0x19, 0x65, 0x43, 0x9f, 0x0d, 0x51,
	0x13, 0xca, 0x01, 0xc5, 0x18, 0x6b, 0xd7, 0x58, 0xcc, 0x53, 0x8e, 0xfb, 0x69, 0x1c, 0x9f, 0x13,
	0x50, 0x2b, 0xa3, 0x04, 0x0b, 0xd3, 0x31, 0x92, 0x61, 0x3b, 0x60, 0xb1, 0xb0, 0xe7, 0x69, 0x17,
	0x58, 0x2c, 0x50, 0x9e, 0x5a, 0xc0, 0x43, 0x2c, 0xc1, 0x29, 0x3a, 0x0c, 0xd1, 0xca, 0x28, 0x5b,
	0x7a, 0x4c, 0x82, 0x86, 0xb0, 0x9b, 0xa0, 0x51, 0x35, 0xfd, 0x4a, 0x2c, 0x52, 0x2a, 0x29, 0x6d,
	0x4b, 0x5c, 0xfb, 0x58, 0xbf, 0x6a, 0x65, 0x94, 0x1d, 0x3d, 0x29, 0x44, 0x5f, 0x40, 0x35, 0xc9,
	0xea, 0x61, 0xdb, 0x10, 0xd7, 0x28, 0xed, 0xa3, 0x15, 0xb4, 0x03, 0x6c, 0x1b, 0xad, 0x8c, 0x82,
	0xf4, 0x39, 0x29, 0xfa, 0x39, 0xec, 0x25, 0x89, 0xa7, 0x13, 0x43, 0xf3, 0xb1, 0xb8, 0x4e, 0xa9,
	0xbf, 0xbd, 0x82, 0x7a, 0x44, 0xc1, 0xad, 0x8c, 0x52, 0xd5, 0x17, 0xc8, 0x17, 0xd1, 0xbb, 0xd8,
	0x72, 0xae, 0xb1, 0x58, 0xba, 0x15, 0xbd, 0x42, 0xc1, 0xf3, 0xf4, 0x4c, 0x1e, 0xa5, 0x9f, 0xb8,
	0xd8, 0xc3, 0xb6, 0x8e, 0x55, 0x7c, 0x8d, 0x6d, 0x5f, 0x84, 0xe5, 0xf4, 0x7d, 0x8e, 0x96, 0x09,
	0x38, 0x42, 0x1f, 0x93, 0xa3, 0x3a, 0x14, 0xb0, 0xeb, 0x3a, 0xae, 0xb8, 0x41, 0xd9, 0xf6, 0xe6,
	0xd8, 0x64, 0x32, 0xdb, 0xca, 0x28, 0x0c, 0x46, 0xf0, 0x96, 0xe6, 0xeb, 0x97, 0xe2, 0x66, 0x0a,
	0xbe, 0x43, 0x66, 0x09, 0x9e, 0xc2, 0x88, 0xef, 0xd3, 0x1f, 0xaa, 0xee, 0x62, 0x62, 0xf2, 0x72,
	0x8a, 0xef, 0x53, 0xb5, 0x06, 0xc5, 0x10, 0xdf, 0xb7, 0x66, 0x43, 0xf4, 0x12, 0x80, 0x51, 0x18,
	0x9a, 0xaf, 0x89, 0x5b, 0x71, 0x87, 0x8d, 0x13, 0x34, 0x35, 0x5f, 0x6b, 0x65, 0x94, 0x92, 0x15,
	0x0c, 0x50, 0x0b, 0xb6, 0x67, 0xca, 0xcc, 0xa1, 0xb6, 0x29, 0xc3, 0x61, 0x3a, 0x03, 0xf7, 0xa5,
	0xb2, 0x15, 0x15, 0xcc, 0xb6, 0x41, 0x63, 0xb8, 0xb2, 0x6c, 0x1b, 0x3c, 0x82, 0xd9, 0x36, 0x68,
	0xfc, 0xbe, 0x02, 0xf6, 0x49, 0x3c, 0x7a, 0x77, 0xa8, 0xf6, 0xc1, 0x62, 0xed, 0x20, 0x76, 0xd9,
	0x72, 0x2c, 0x72, 0xbf, 0x80, 0x2a, 0xd3, 0x4f, 0xf8, 0x00, 0x4a, 0x09, 0x0e, 0x4a, 0x94, 0xf4,
	0x00, 0x64, 0xcd, 0x49, 0xd1, 0x19, 0x6c, 0x51, 0xa9, 0xa5, 0x5d, 0x61, 0x57, 0xd5, 0x0c, 0x43,
	0xdc, 0x5d, 0x66, 0x1e, 0x0a, 0x3b, 0x36, 0x66, 0xe6, 0x09, 0x04, 0x68, 0x00, 0x28, 0x42, 0x44,
	0x7f, 0x62, 0x43, 0xac, 0xa6, 0xe4, 0x84, 0x19, 0x59, 0x87, 0x21, 0x49, 0x4e, 0xb0, 0x92, 0x42,
	0xd4, 0x87, 0x88, 0x30, 0x08, 0xab, 0x7b, 0x94, 0xf3, 0x5b, 0x4b, 0x38, 0xc3, 0x90, 0xaa, 0x58,
	0x09, 0x59, 0x82, 0xd1, 0x37, 0xf5, 0x2b, 0xec, 0x8b, 0x7b, 0x2b, 0x19, 0x87, 0x14, 0x18, 0x67,
	0x64, 0x32, 0x74, 0x0a, 0x65, 0xdb, 0xf1, 0xcd, 0xb7, 0xa6, 0xae, 0xf9, 0xa6, 0x63, 0x7b, 0xe2,
	0x7e, 0x8a, 0x01, 0xbb, 0x51, 0x14, 0x31, 0x60, 0x4c, 0x0d, 0x3d, 0x82, 0x9c, 0x3b, 0xd1, 0x45,
	0x91, 0x6a, 0x6f, 0x47, 0x13, 0xb2, 0x32, 0xd1, 0x5b, 0x19, 0x85, 0xcc, 0xa2, 0x27, 0x50, 0xf4,
	0x7c, 0xcd, 0x9f, 0x7a, 0xe2, 0x47, 0x14, 0xb7, 0x3f, 0xb7, 0xca, 0x80, 0x4e, 0xb7, 0x32, 0x0a,
	0x07, 0x92, 0xab, 0x83, 0xfd, 0x52, 0xdf, 0x3a, 0xe3, 0xb1, 0xf3, 0x4e, 0xac, 0xa5, 0x5c, 0x1d,
	0x4c, 0xf3, 0x94, 0x82, 0xc8, 0xd5, 0xe1, 0x45, 0xc6, 0xe8, 0x0d, 0xdc, 0xe3, 0x2c, 0x09, 0x0f,
	0x3c, 0xa0, 0x6c, 0x9f, 0xa4, 0xb0, 0x25, 0x5d, 0x70, 0xd7, 0x9b, 0x17, 0xa3, 0xd7, 0xb0, 0xcd,
	0xb9, 0xa7, 0x36, 0xdf, 0xe3, 0xc7, 0x94, 0xf5, 0x41, 0x0a, 0xeb, 0x88, 0xc3, 0xc8, 0xdd, 0xe4,
	0xc5, 0x24, 0x91, 0xaf, 0xe5, 0x39, 0xfe, 0xfe, 0xd2, 0xaf, 0x0d, 0x73, 0x3b, 0xff, 0x5a, 0x9e,
	0xd3, 0x5f, 0xc1, 0x86, 0xe7, 0xbb, 0x58, 0xb3, 0x58, 0xce, 0x39, 0x4c, 0x09, 0xd7, 0x01, 0xc5,
	0xf0, 0xa4, 0x03, 0x5e, 0x38, 0x62, 0xd6, 0xa2, 0xfa, 0x09, 0x6b, 0x3d, 0x48, 0xb5, 0x16, 0x41,
	0x2f, 0xb0, 0xd6, 0x9c, 0xf8, 0xa4, 0x04, 0x6b, 0xfc, 0x9e, 0x91, 0x7e, 0x2b, 0xc0, 0x1a, 0xcf,
	0xf6, 0x68, 0x0b, 0xb2, 0x61, 0xad, 0x92, 0x35, 0x49, 0xba, 0x2a, 0x05, 0x6b, 0x7b, 0x62, 0xf6,
	0x61, 0x6e, 0xa1, 0x11, 0x46, 0x1e, 0x76, 0x03, 0x76, 0x65, 0x86, 0x47, 0x4f, 0x20, 0xef, 0xe1,
	0xf1, 0x5b, 0x5e, 0xa9, 0xac, 0xd0, 0xa3, 0x50, 0xe9, 0x3f, 0x02, 0x6c, 0x44, 0x0a, 0x18, 0xb4,
	0x07, 0x45, 0x5f, 0x73, 0x2f, 0xb0, 0xcf, 0xf7, 0xc4, 0x47, 0x08, 0x41, 0xde, 0xbf, 0x99, 0x60,
	0x5a, 0x3f, 0x15, 0x14, 0xfa, 0x1b, 0xfd, 0x08, 0x36, 0x48, 0xbd, 0x66, 0x7a, 0x3e, 0x21, 0xe4,
	0xab, 0xd6, 0xea, 0xac, 0xae, 0xab, 0x07, 0x75, 0x5d, 0xfd, 0xc4, 0x71, 0xc6, 0x3f, 0xd5, 0xc6,
	0x53, 0xac, 0x44, 0xe1, 0xe8, 0x29, 0x14, 0x2f, 0x4d, 0xc3, 0xc0, 0x36, 0x2f, 0x8a, 0x96, 0x29,
	0x72, 0xa4, 0x24, 0x43, 0x7e, 0x48, 0x56, 0xae, 0x42, 0x65, 0xf8, 0x65, 0x5f, 0x56, 0x47, 0xdd,
	0x41, 0x5f, 0x6e, 0xb4, 0x4f, 0xdb, 0x72, 0xb3, 0x92, 0x41, 0xeb, 0x90, 0x57, 0x7a, 0xbd, 0x4e,
	0x45, 0x40, 0x08, 0xb6, 0x9a, 0x6d, 0x45, 0x6e, 0x0c, 0xd5, 0x8e, 0x3c, 0x18, 0x1c, 0x9f, 0xc9,
	0x95, 0x2c, 0x2a, 0x41, 0xe1, 0x4c, 0xe9, 0x8d, 0xfa, 0x95, 0x9c, 0xf4, 0x7d, 0xd8, 0x8c, 0x16,
	0x5c, 0xe8, 0x3e, 0x40, 0x70, 0x59, 0x87, 0x87, 0x51, 0xe2, 0x92, 0xb6, 0x21, 0xfd, 0x3b, 0x0b,
	0x3b, 0x73, 0xd5, 0xd0, 0x0a, 0x25, 0x32, 0x1d, 0xd4, 0x15, 0xa6, 0x41, 0xcd, 0x56, 0x52, 0x4a,
	0x5c, 0xd2, 0x36, 0xd0, 0x11, 0xe4, 0x75, 0xc7, 0x08, 0x8c, 0x76, 0x30, 0xf7, 0xed, 0x6d, 0xdb,
	0x7f, 0xf6, 0x94, 0x7d, 0x3c, 0x05, 0xa2, 0x1a, 0xac, 0x4f, 0x3d, 0xec, 0xda, 0x9a, 0xc5, 0xaa,
	0xc8, 0x92, 0x12, 0x8e, 0xd1, 0x4b, 0xd8, 0x60, 0xf7, 0xb4, 0x4a, 0x8e, 0x39, 0x2c, 0x0e, 0x93,
	0x9c, 0xc3, 0xa0, 0x02, 0x57, 0x80, 0xc1, 0x89, 0x80, 0x28, 0xb3, 0x98, 0x63, 0xca, 0xc5, 0xd5,
	0xca, 0x0c, 0x4e, 0x95, 0x5f, 0x00, 0x84, 0x67, 0xea, 0xf3, 0x9a, 0x6f, 0xd9, 0x41, 0x46, 0xd0,
	0x52, 0x07, 0xd0, 0x7c, 0x31, 0xb8, 0xca, 0xac, 0x22, 0xac, 0xe9, 0x8e, 0x4d, 0x57, 0x63, 0x36,
	0x0d, 0x86, 0x92, 0x0d, 0xd5, 0x45, 0x05, 0xe0, 0x37, 0x3c, 0xa7, 0xc8, 0x7a, 0xb9, 0xf8, 0x7a,
	0xc3, 0xe4, 0x7a, 0xfc, 0xaa, 0xfa, 0x46, 0xeb, 0x49, 0x7f, 0x14, 0x42, 0xda, 0x78, 0xb6, 0x5d,
	0x41, 0xfb, 0x0c, 0x0a, 0xa4, 0xc0, 0xb9, 0x65, 0xce, 0x60, 0x58, 0xf4, 0x19, 0x14, 0x69, 0x61,
	0xe3, 0x89, 0xb9, 0xdb, 0x68, 0x71, 0xb0, 0xf4, 0xdf, 0x2c, 0x14, 0x68, 0x7d, 0x49, 0xb2, 0x02,
	0xf5, 0x62, 0x81, 0x65, 0x05, 0xea, 0xa8, 0x62, 0x98, 0xe8, 0x82, 0x13, 0xe2, 0x43, 0xf4, 0x63,
	0x6e, 0xcb, 0xf7, 0x3e, 0x5f, 0xef, 0xd1, 0xe2, 0xb2, 0xb5, 0xde, 0x60, 0x28, 0xd9, 0xf6, 0xdd,
	0x1b, 0x25, 0xd0, 0xa9, 0xbd, 0x80, 0xcd, 0xe8, 0x04, 0xe9, 0xf3, 0xae, 0xf0, 0x4d, 0xd0, 0xe7,
	0x5d, 0xe1, 0x1b, 0x54, 0x85, 0xc2, 0x35, 0x71, 0x33, 0xbe, 0x30, 0x1b, 0xbc, 0xc8, 0xfe, 0x40,
	0x90, 0xfe, 0x25, 0x40, 0xbe, 0x41, 0x76, 0x77, 0x0f, 0x76, 0x94, 0x51, 0x77, 0xd8, 0xee, 0xc8,
	0xaa, 0xfc, 0xb3, 0x86, 0xdc, 0x1f, 0xb6, 0x7b, 0xdd, 0x4a, 0x06, 0x89, 0x50, 0x1d, 0x75, 0x15,
	0xb9, 0xd1, 0x3b, 0xeb, 0xb6, 0xdf, 0xc8, 0x4d, 0xb5, 0x7f, 0xfc, 0xe5, 0xe7, 0xbd, 0xe3, 0x66,
	0x45, 0x40, 0xbb, 0xb0, 0xdd, 0x69, 0x0f, 0x06, 0xed, 0xee, 0x59, 0x28, 0xcc, 0xa2, 0x32, 0x94,
	0x4e, 0x8e, 0x9b, 0x6a, 0xbb, 0xdb, 0x1f, 0x0d, 0x2b, 0x39, 0x8a, 0x39, 0x1e, 0x36, 0x5a, 0x6a,
	0xb7, 0x37, 0x54, 0x4f, 0x7b, 0xa3, 0x6e, 0xb3, 0x92, 0x47, 0xfb, 0xb0, 0xcb, 0x84, 0xaf, 0x7b,
	0xed, 0xae, 0xaa, 0xc8, 0xaf, 0xe5, 0xc6, 0x50, 0x6e, 0x56, 0x0a, 0xe8, 0x10, 0x6a, 0xc1, 0x16,
	0x4e, 0x47, 0xdd, 0x06, 0xd9, 0x41, 0x44, 0xb1, 0xb8, 0x70, 0x7e, 0xb6, 0xd7, 0x35, 0xe9, 0x57,
	0x59, 0x28, 0xd0, 0x12, 0x07, 0x7d, 0x04, 0xeb, 0xac, 0xbc, 0x0c, 0x3d, 0x62, 0x8d, 0x8e, 0xdb,
	0x06, 0xfa, 0x04, 0xca, 0xda, 0xd4, 0xbf, 0x74, 0x5c, 0xd3, 0xd7, 0x7c, 0xf3, 0x9a, 0x99, 0x64,
	0x5d, 0x89, 0x0b, 0xd1, 0x53, 0x28, 0x8c, 0xb5, 0x73, 0x3c, 0x0e, 0x7b, 0xdb, 0x64, 0xe4, 0x0e,
	0x7c, 0xd7, 0xb4, 0x2f, 0x58, 0xec, 0x32, 0x28, 0x39, 0x73, 0xcf, 0xfc, 0x25, 0x4b, 0x42, 0x05,
	0x85, 0xfe, 0x8e, 0xdf, 0x5a, 0x85, 0xaf, 0x79, 0x6b, 0x15, 0x6f, 0x7f, 0x6b, 0x95, 0x61, 0x23,
	0xd2, 0x79, 0x48, 0xbf, 0x13, 0xa0, 0x14, 0xb6, 0x01, 0xcb, 0xac, 0xf2, 0x43, 0x58, 0x0f, 0xd6,
	0xe5, 0x2f, 0x01, 0x2b, 0x96, 0x0b, 0xe1, 0x68, 0x1f, 0xd6, 0x9c, 0x89, 0x1a, 0xe6, 0xec, 0x9c,
	0x52, 0x74, 0x26, 0xd4, 0xa3, 0x10, 0xe4, 0x69, 0xb5, 0x41, 0xec, 0xb1, 0xa9, 0xd0, 0xdf, 0xd2,
	0xef, 0x05, 0x28, 0xc7, 0xfa, 0x92, 0x65, 0x9b, 0x8a, 0x30, 0x67, 0x17, 0x32, 0xe7, 0x66, 0xcc,
	0x71, 0x4b, 0xe7, 0xef, 0x66, 0x69, 0x12, 0x05, 0xa5, 0xb0, 0xd3, 0x41, 0x07, 0xc9, 0x2d, 0xb5,
	0x32, 0xb3, 0x4d, 0xed, 0x41, 0xc1, 0x77, 0xae, 0xb0, 0xcd, 0x42, 0x89, 0x34, 0x86, 0x74, 0x88,
	0x9a, 0xb0, 0x6e, 0x61, 0x5f, 0xe3, 0xfb, 0x22, 0xcb, 0x3f, 0x4e, 0x6f, 0xa6, 0xea, 0x1d, 0x0e,
	0x65, 0x91, 0x1c, 0x6a, 0xd6, 0x5e, 0x42, 0x39, 0x36, 0x75, 0x97, 0x58, 0x3e, 0xc9, 0x93, 0x92,
	0x49, 0xfa, 0x0e, 0xc0, 0xac, 0xed, 0x5a, 0x62, 0x5e, 0xe9, 0x0f, 0x02, 0xa0, 0xf9, 0xbe, 0x6a,
	0xd9, 0x81, 0x7c, 0xc8, 0x5c, 0xfa, 0xb7, 0x1c, 0xf7, 0x94, 0xb0, 0x23, 0x3b, 0x80, 0x92, 0x65,
	0xda, 0xaa, 0xee, 0x4c, 0x6d, 0x9f, 0x27, 0xd6, 0x75, 0xcb, 0xb4, 0x1b, 0x64, 0x4c, 0x27, 0xb5,
	0xf7, 0x7c, 0x32, 0xcb, 0x27, 0xb5, 0xf7, 0x6c, 0xb2, 0x0a, 0x85, 0x5f, 0x4c, 0xb1, 0x7b, 0xc3,
	0x6f, 0x2a, 0x36, 0x40, 0x1a, 0xec, 0x78, 0x34, 0x8a, 0xd5, 0x89, 0xeb, 0x4c, 0xb0, 0xeb, 0x9b,
	0xa1, 0xe7, 0x3c, 0x5f, 0xde, 0x2d, 0xf2, 0xe8, 0xef, 0x87, 0x6a, 0xec, 0x18, 0x2b, 0x5e, 0x42,
	0x8c, 0x0c, 0x40, 0xf6, 0xd4, 0xc2, 0xae, 0xa9, 0x47, 0xd7, 0x60, 0x79, 0xe0, 0xb3, 0x15, 0x6b,
	0x74, 0x99, 0x62, 0x72, 0x91, 0x1d, 0x3b, 0x29, 0xaf, 0x35, 0xe0, 0xde, 0xc2, 0x0d, 0xdd, 0xc5,
	0x79, 0x6a, 0x4d, 0xd8, 0x5b, 0xbc, 0xe2, 0x2a, 0x16, 0x21, 0x7a, 0x9d, 0xfc, 0xa3, 0x00, 0x3b,
	0x73, 0xbd, 0x30, 0xad, 0x9d, 0x59, 0x67, 0x1a, 0xd4, 0xce, 0xac, 0xd5, 0x8c, 0x06, 0x5a, 0x36,
	0x35, 0xd0, 0x72, 0xf1, 0x40, 0x3b, 0x83, 0x02, 0xa9, 0xef, 0x82, 0xa3, 0x7a, 0xb2, 0xba, 0x17,
	0x8f, 0x48, 0x88, 0xab, 0x29, 0x4c, 0x1f, 0xc9, 0x3c, 0xbd, 0xb2, 0xaa, 0xf0, 0x6b, 0xf0, 0x50,
	0xf5, 0xda, 0x3f, 0x73, 0xb0, 0x15, 0x9f, 0x88, 0x65, 0x53, 0xe1, 0x6e, 0xd9, 0xd4, 0x5f, 0xe4,
	0x94, 0xcc, 0x61, 0xce, 0xee, 0xbc, 0xc3, 0x5b, 0xfb, 0xe9, 0xbb, 0x85, 0x7e, 0x5a, 0xa4, 0xcb,
	0xb6, 0xee, 0xbe, 0xec, 0xff, 0xa3, 0xeb, 0xf2, 0xec, 0xf9, 0x29, 0x54, 0x92, 0xef, 0x2e, 0x69,
	0xee, 0x1b, 0xc7, 0xf2, 0xd7, 0x93, 0x34, 0x6c, 0x0f, 0xca, 0xb1, 0xf7, 0x12, 0xf4, 0x2a, 0xf9,
	0xcc, 0x22, 0x50, 0x6b, 0x8b, 0xd1, 0x87, 0x92, 0xa8, 0x46, 0xe2, 0x79, 0x45, 0x92, 0xa1, 0xc8,
	0x5a, 0xfe, 0xf8, 0xcd, 0x27, 0xdc, 0xf1, 0xe6, 0xfb, 0x2e, 0x6c, 0x46, 0xdf, 0x49, 0x48, 0xf6,
	0x27, 0xd1, 0xa1, 0x9a, 0x06, 0xe3, 0x2a, 0x29, 0x6b, 0x64, 0xdc, 0x36, 0x3c, 0xe9, 0xd7, 0x02,
	0xec, 0x2e, 0x78, 0x05, 0xf9, 0xa0, 0xb7, 0xc2, 0xf7, 0x60, 0x2b, 0xfe, 0x64, 0xb2, 0x6c, 0xc3,
	0xcd, 0xe0, 0xdb, 0x78, 0xc3, 0xf3, 0x3c, 0x7c, 0x6c, 0x12, 0x6e, 0x51, 0xd5, 0x71, 0xac, 0x34,
	0x26, 0x86, 0x76, 0xb1, 0x66, 0x91, 0xb2, 0xc3, 0x8a, 0x14, 0xf5, 0x16, 0x2f, 0xea, 0xbd, 0xe9,
	0xf9, 0x57, 0x58, 0x0f, 0xdb, 0x2e, 0x3e, 0x44, 0x87, 0x00, 0xde, 0xf4, 0x7c, 0x56, 0xd7, 0x93,
	0xc9, 0x88, 0x84, 0x78, 0x22, 0x2b, 0x31, 0x59, 0xd3, 0xca, 0x06, 0xd2, 0x6f, 0x04, 0x80, 0xd9,
	0x33, 0x0c, 0x3a, 0x22, 0x5b, 0x26, 0x23, 0xbe, 0xe5, 0xfd, 0x94, 0x97, 0x16, 0x85, 0xc3, 0x88,
	0x5d, 0x3d, 0x6c, 0x1b, 0xd8, 0xbd, 0x5d, 0x19, 0xc7, 0xc1, 0xb1, 0x8a, 0xaa, 0xc4, 0x6b, 0xb5,
	0xbf, 0xd2, 0xf3, 0x9e, 0x7b, 0xb0, 0xb9, 0xfb, 0x9e, 0x3e, 0xa4, 0x83, 0xfc, 0x5d, 0x80, 0xcd,
	0xe8, 0x04, 0x29, 0x22, 0xb9, 0x7f, 0x04, 0x11, 0xc9, 0xdc, 0x83, 0xf4, 0x8d, 0x1e, 0xf6, 0x3c,
	0xd3, 0xb1, 0x23, 0xfd, 0x26, 0x97, 0xb4, 0x8d, 0xd8, 0xb3, 0x42, 0x2e, 0xf1, 0xac, 0xf0, 0x30,
	0xfe, 0xbe, 0x93, 0xa7, 0x1d, 0x44, 0xec, 0x0d, 0x67, 0xe6, 0x6a, 0x85, 0xdb, 0xbb, 0xda, 0xc9,
	0x29, 0x1c, 0xe8, 0x8e, 0x55, 0x9f, 0xfd, 0xa9, 0x17, 0x7e, 0xb3, 0xaf, 0x4d, 0xcc, 0x93, 0xad,
	0x2e, 0x1d, 0x29, 0xdc, 0x00, 0x7d, 0xe1, 0x4d, 0x81, 0x4e, 0xfc, 0x29, 0x9b, 0xef, 0xfe, 0xa4,
	0x7f, 0xf2, 0xe7, 0x6c, 0x91, 0x01, 0xce, 0x8b, 0x74, 0x95, 0x67, 0xff, 0x0b, 0x00, 0x00, 0xff,
	0xff, 0x49, 0xe0, 0x91, 0x17, 0x92, 0x1c, 0x00, 0x00,
}