// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: client.proto

package protocol

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type MethodType int32

const (
	MethodTypeConnect       MethodType = 0
	MethodTypeSubscribe     MethodType = 1
	MethodTypeUnsubscribe   MethodType = 2
	MethodTypePublish       MethodType = 3
	MethodTypePresence      MethodType = 4
	MethodTypePresenceStats MethodType = 5
	MethodTypeHistory       MethodType = 6
	MethodTypePing          MethodType = 7
	MethodTypeSend          MethodType = 8
	MethodTypeRPC           MethodType = 9
	MethodTypeRefresh       MethodType = 10
	MethodTypeSubRefresh    MethodType = 11
)

var MethodType_name = map[int32]string{
	0:  "CONNECT",
	1:  "SUBSCRIBE",
	2:  "UNSUBSCRIBE",
	3:  "PUBLISH",
	4:  "PRESENCE",
	5:  "PRESENCE_STATS",
	6:  "HISTORY",
	7:  "PING",
	8:  "SEND",
	9:  "RPC",
	10: "REFRESH",
	11: "SUB_REFRESH",
}

var MethodType_value = map[string]int32{
	"CONNECT":        0,
	"SUBSCRIBE":      1,
	"UNSUBSCRIBE":    2,
	"PUBLISH":        3,
	"PRESENCE":       4,
	"PRESENCE_STATS": 5,
	"HISTORY":        6,
	"PING":           7,
	"SEND":           8,
	"RPC":            9,
	"REFRESH":        10,
	"SUB_REFRESH":    11,
}

func (x MethodType) String() string {
	return proto.EnumName(MethodType_name, int32(x))
}

func (MethodType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{0}
}

type PushType int32

const (
	PushTypePublication PushType = 0
	PushTypeJoin        PushType = 1
	PushTypeLeave       PushType = 2
	PushTypeUnsub       PushType = 3
	PushTypeMessage     PushType = 4
	PushTypeSub         PushType = 5
)

var PushType_name = map[int32]string{
	0: "PUBLICATION",
	1: "JOIN",
	2: "LEAVE",
	3: "UNSUB",
	4: "MESSAGE",
	5: "SUB",
}

var PushType_value = map[string]int32{
	"PUBLICATION": 0,
	"JOIN":        1,
	"LEAVE":       2,
	"UNSUB":       3,
	"MESSAGE":     4,
	"SUB":         5,
}

func (x PushType) String() string {
	return proto.EnumName(PushType_name, int32(x))
}

func (PushType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{1}
}

type Error struct {
	Code    uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message"`
}

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_014de31d7ac8c57c, []int{0}
}
func (m *Error) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Error.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
	return m.Size()
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

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

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

type Command struct {
	ID     uint32     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Method MethodType `protobuf:"varint,2,opt,name=method,proto3,enum=protocol.MethodType" json:"method,omitempty"`
	Params Raw        `protobuf:"bytes,3,opt,name=params,proto3,customtype=Raw" json:"params,omitempty"`
}

func (m *Command) Reset()         { *m = Command{} }
func (m *Command) String() string { return proto.CompactTextString(m) }
func (*Command) ProtoMessage()    {}
func (*Command) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{1}
}
func (m *Command) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Command) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Command.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Command) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Command.Merge(m, src)
}
func (m *Command) XXX_Size() int {
	return m.Size()
}
func (m *Command) XXX_DiscardUnknown() {
	xxx_messageInfo_Command.DiscardUnknown(m)
}

var xxx_messageInfo_Command proto.InternalMessageInfo

func (m *Command) GetID() uint32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Command) GetMethod() MethodType {
	if m != nil {
		return m.Method
	}
	return MethodTypeConnect
}

type Reply struct {
	ID     uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Error  *Error `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	Result Raw    `protobuf:"bytes,3,opt,name=result,proto3,customtype=Raw" json:"result,omitempty"`
}

func (m *Reply) Reset()         { *m = Reply{} }
func (m *Reply) String() string { return proto.CompactTextString(m) }
func (*Reply) ProtoMessage()    {}
func (*Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{2}
}
func (m *Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Reply.Merge(m, src)
}
func (m *Reply) XXX_Size() int {
	return m.Size()
}
func (m *Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_Reply proto.InternalMessageInfo

func (m *Reply) GetID() uint32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Reply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type Push struct {
	Type    PushType `protobuf:"varint,1,opt,name=type,proto3,enum=protocol.PushType" json:"type,omitempty"`
	Channel string   `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel,omitempty"`
	Data    Raw      `protobuf:"bytes,3,opt,name=data,proto3,customtype=Raw" json:"data"`
}

func (m *Push) Reset()         { *m = Push{} }
func (m *Push) String() string { return proto.CompactTextString(m) }
func (*Push) ProtoMessage()    {}
func (*Push) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{3}
}
func (m *Push) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Push) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Push.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Push) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Push.Merge(m, src)
}
func (m *Push) XXX_Size() int {
	return m.Size()
}
func (m *Push) XXX_DiscardUnknown() {
	xxx_messageInfo_Push.DiscardUnknown(m)
}

var xxx_messageInfo_Push proto.InternalMessageInfo

func (m *Push) GetType() PushType {
	if m != nil {
		return m.Type
	}
	return PushTypePublication
}

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

type ClientInfo struct {
	User     string `protobuf:"bytes,1,opt,name=user,proto3" json:"user"`
	Client   string `protobuf:"bytes,2,opt,name=client,proto3" json:"client"`
	ConnInfo Raw    `protobuf:"bytes,3,opt,name=conn_info,json=connInfo,proto3,customtype=Raw" json:"conn_info,omitempty"`
	ChanInfo Raw    `protobuf:"bytes,4,opt,name=chan_info,json=chanInfo,proto3,customtype=Raw" json:"chan_info,omitempty"`
}

func (m *ClientInfo) Reset()         { *m = ClientInfo{} }
func (m *ClientInfo) String() string { return proto.CompactTextString(m) }
func (*ClientInfo) ProtoMessage()    {}
func (*ClientInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{4}
}
func (m *ClientInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClientInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClientInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ClientInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientInfo.Merge(m, src)
}
func (m *ClientInfo) XXX_Size() int {
	return m.Size()
}
func (m *ClientInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ClientInfo proto.InternalMessageInfo

func (m *ClientInfo) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

func (m *ClientInfo) GetClient() string {
	if m != nil {
		return m.Client
	}
	return ""
}

type Publication struct {
	Seq    uint32      `protobuf:"varint,1,opt,name=seq,proto3" json:"seq,omitempty"`
	Gen    uint32      `protobuf:"varint,2,opt,name=gen,proto3" json:"gen,omitempty"`
	UID    string      `protobuf:"bytes,3,opt,name=uid,proto3" json:"uid,omitempty"`
	Data   Raw         `protobuf:"bytes,4,opt,name=data,proto3,customtype=Raw" json:"data"`
	Info   *ClientInfo `protobuf:"bytes,5,opt,name=info,proto3" json:"info,omitempty"`
	Offset uint64      `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`
}

func (m *Publication) Reset()         { *m = Publication{} }
func (m *Publication) String() string { return proto.CompactTextString(m) }
func (*Publication) ProtoMessage()    {}
func (*Publication) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{5}
}
func (m *Publication) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Publication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Publication.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Publication) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Publication.Merge(m, src)
}
func (m *Publication) XXX_Size() int {
	return m.Size()
}
func (m *Publication) XXX_DiscardUnknown() {
	xxx_messageInfo_Publication.DiscardUnknown(m)
}

var xxx_messageInfo_Publication proto.InternalMessageInfo

func (m *Publication) GetSeq() uint32 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *Publication) GetGen() uint32 {
	if m != nil {
		return m.Gen
	}
	return 0
}

func (m *Publication) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *Publication) GetInfo() *ClientInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *Publication) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type Join struct {
	Info ClientInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info"`
}

func (m *Join) Reset()         { *m = Join{} }
func (m *Join) String() string { return proto.CompactTextString(m) }
func (*Join) ProtoMessage()    {}
func (*Join) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{6}
}
func (m *Join) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Join) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Join.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Join) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Join.Merge(m, src)
}
func (m *Join) XXX_Size() int {
	return m.Size()
}
func (m *Join) XXX_DiscardUnknown() {
	xxx_messageInfo_Join.DiscardUnknown(m)
}

var xxx_messageInfo_Join proto.InternalMessageInfo

func (m *Join) GetInfo() ClientInfo {
	if m != nil {
		return m.Info
	}
	return ClientInfo{}
}

type Leave struct {
	Info ClientInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info"`
}

func (m *Leave) Reset()         { *m = Leave{} }
func (m *Leave) String() string { return proto.CompactTextString(m) }
func (*Leave) ProtoMessage()    {}
func (*Leave) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{7}
}
func (m *Leave) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Leave) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Leave.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Leave) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Leave.Merge(m, src)
}
func (m *Leave) XXX_Size() int {
	return m.Size()
}
func (m *Leave) XXX_DiscardUnknown() {
	xxx_messageInfo_Leave.DiscardUnknown(m)
}

var xxx_messageInfo_Leave proto.InternalMessageInfo

func (m *Leave) GetInfo() ClientInfo {
	if m != nil {
		return m.Info
	}
	return ClientInfo{}
}

type Unsub struct {
	Resubscribe bool `protobuf:"varint,1,opt,name=resubscribe,proto3" json:"resubscribe,omitempty"`
}

func (m *Unsub) Reset()         { *m = Unsub{} }
func (m *Unsub) String() string { return proto.CompactTextString(m) }
func (*Unsub) ProtoMessage()    {}
func (*Unsub) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{8}
}
func (m *Unsub) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Unsub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Unsub.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Unsub) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Unsub.Merge(m, src)
}
func (m *Unsub) XXX_Size() int {
	return m.Size()
}
func (m *Unsub) XXX_DiscardUnknown() {
	xxx_messageInfo_Unsub.DiscardUnknown(m)
}

var xxx_messageInfo_Unsub proto.InternalMessageInfo

func (m *Unsub) GetResubscribe() bool {
	if m != nil {
		return m.Resubscribe
	}
	return false
}

type Sub struct {
	Recoverable bool   `protobuf:"varint,1,opt,name=recoverable,proto3" json:"recoverable,omitempty"`
	Seq         uint32 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`
	Gen         uint32 `protobuf:"varint,3,opt,name=gen,proto3" json:"gen,omitempty"`
	Epoch       string `protobuf:"bytes,4,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Offset      uint64 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	Positioned  bool   `protobuf:"varint,6,opt,name=positioned,proto3" json:"positioned,omitempty"`
}

func (m *Sub) Reset()         { *m = Sub{} }
func (m *Sub) String() string { return proto.CompactTextString(m) }
func (*Sub) ProtoMessage()    {}
func (*Sub) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{9}
}
func (m *Sub) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Sub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Sub.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Sub) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sub.Merge(m, src)
}
func (m *Sub) XXX_Size() int {
	return m.Size()
}
func (m *Sub) XXX_DiscardUnknown() {
	xxx_messageInfo_Sub.DiscardUnknown(m)
}

var xxx_messageInfo_Sub proto.InternalMessageInfo

func (m *Sub) GetRecoverable() bool {
	if m != nil {
		return m.Recoverable
	}
	return false
}

func (m *Sub) GetSeq() uint32 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *Sub) GetGen() uint32 {
	if m != nil {
		return m.Gen
	}
	return 0
}

func (m *Sub) GetEpoch() string {
	if m != nil {
		return m.Epoch
	}
	return ""
}

func (m *Sub) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Sub) GetPositioned() bool {
	if m != nil {
		return m.Positioned
	}
	return false
}

type Message struct {
	Data Raw `protobuf:"bytes,1,opt,name=data,proto3,customtype=Raw" json:"data"`
}

func (m *Message) Reset()         { *m = Message{} }
func (m *Message) String() string { return proto.CompactTextString(m) }
func (*Message) ProtoMessage()    {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{10}
}
func (m *Message) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Message.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return m.Size()
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

type ConnectRequest struct {
	Token   string                       `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Data    Raw                          `protobuf:"bytes,2,opt,name=data,proto3,customtype=Raw" json:"data,omitempty"`
	Subs    map[string]*SubscribeRequest `protobuf:"bytes,3,rep,name=subs,proto3" json:"subs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Name    string                       `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Version string                       `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
}

func (m *ConnectRequest) Reset()         { *m = ConnectRequest{} }
func (m *ConnectRequest) String() string { return proto.CompactTextString(m) }
func (*ConnectRequest) ProtoMessage()    {}
func (*ConnectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{11}
}
func (m *ConnectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectRequest.Merge(m, src)
}
func (m *ConnectRequest) XXX_Size() int {
	return m.Size()
}
func (m *ConnectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectRequest proto.InternalMessageInfo

func (m *ConnectRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *ConnectRequest) GetSubs() map[string]*SubscribeRequest {
	if m != nil {
		return m.Subs
	}
	return nil
}

func (m *ConnectRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ConnectRequest) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type ConnectResult struct {
	Client  string                      `protobuf:"bytes,1,opt,name=client,proto3" json:"client"`
	Version string                      `protobuf:"bytes,2,opt,name=version,proto3" json:"version"`
	Expires bool                        `protobuf:"varint,3,opt,name=expires,proto3" json:"expires,omitempty"`
	TTL     uint32                      `protobuf:"varint,4,opt,name=ttl,proto3" json:"ttl,omitempty"`
	Data    Raw                         `protobuf:"bytes,5,opt,name=data,proto3,customtype=Raw" json:"data,omitempty"`
	Subs    map[string]*SubscribeResult `protobuf:"bytes,6,rep,name=subs,proto3" json:"subs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ConnectResult) Reset()         { *m = ConnectResult{} }
func (m *ConnectResult) String() string { return proto.CompactTextString(m) }
func (*ConnectResult) ProtoMessage()    {}
func (*ConnectResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{12}
}
func (m *ConnectResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnectResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnectResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnectResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectResult.Merge(m, src)
}
func (m *ConnectResult) XXX_Size() int {
	return m.Size()
}
func (m *ConnectResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectResult.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectResult proto.InternalMessageInfo

func (m *ConnectResult) GetClient() string {
	if m != nil {
		return m.Client
	}
	return ""
}

func (m *ConnectResult) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *ConnectResult) GetExpires() bool {
	if m != nil {
		return m.Expires
	}
	return false
}

func (m *ConnectResult) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

func (m *ConnectResult) GetSubs() map[string]*SubscribeResult {
	if m != nil {
		return m.Subs
	}
	return nil
}

type RefreshRequest struct {
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token"`
}

func (m *RefreshRequest) Reset()         { *m = RefreshRequest{} }
func (m *RefreshRequest) String() string { return proto.CompactTextString(m) }
func (*RefreshRequest) ProtoMessage()    {}
func (*RefreshRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{13}
}
func (m *RefreshRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RefreshRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RefreshRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RefreshRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RefreshRequest.Merge(m, src)
}
func (m *RefreshRequest) XXX_Size() int {
	return m.Size()
}
func (m *RefreshRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RefreshRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RefreshRequest proto.InternalMessageInfo

func (m *RefreshRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

type RefreshResult struct {
	Client  string `protobuf:"bytes,1,opt,name=client,proto3" json:"client"`
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version"`
	Expires bool   `protobuf:"varint,3,opt,name=expires,proto3" json:"expires,omitempty"`
	TTL     uint32 `protobuf:"varint,4,opt,name=ttl,proto3" json:"ttl,omitempty"`
}

func (m *RefreshResult) Reset()         { *m = RefreshResult{} }
func (m *RefreshResult) String() string { return proto.CompactTextString(m) }
func (*RefreshResult) ProtoMessage()    {}
func (*RefreshResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{14}
}
func (m *RefreshResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RefreshResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RefreshResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RefreshResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RefreshResult.Merge(m, src)
}
func (m *RefreshResult) XXX_Size() int {
	return m.Size()
}
func (m *RefreshResult) XXX_DiscardUnknown() {
	xxx_messageInfo_RefreshResult.DiscardUnknown(m)
}

var xxx_messageInfo_RefreshResult proto.InternalMessageInfo

func (m *RefreshResult) GetClient() string {
	if m != nil {
		return m.Client
	}
	return ""
}

func (m *RefreshResult) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *RefreshResult) GetExpires() bool {
	if m != nil {
		return m.Expires
	}
	return false
}

func (m *RefreshResult) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

type SubscribeRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"`
	Token   string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
	Recover bool   `protobuf:"varint,3,opt,name=recover,proto3" json:"recover,omitempty"`
	Seq     uint32 `protobuf:"varint,4,opt,name=seq,proto3" json:"seq,omitempty"`
	Gen     uint32 `protobuf:"varint,5,opt,name=gen,proto3" json:"gen,omitempty"`
	Epoch   string `protobuf:"bytes,6,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Offset  uint64 `protobuf:"varint,7,opt,name=offset,proto3" json:"offset,omitempty"`
}

func (m *SubscribeRequest) Reset()         { *m = SubscribeRequest{} }
func (m *SubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*SubscribeRequest) ProtoMessage()    {}
func (*SubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{15}
}
func (m *SubscribeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubscribeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeRequest.Merge(m, src)
}
func (m *SubscribeRequest) XXX_Size() int {
	return m.Size()
}
func (m *SubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeRequest proto.InternalMessageInfo

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

func (m *SubscribeRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *SubscribeRequest) GetRecover() bool {
	if m != nil {
		return m.Recover
	}
	return false
}

func (m *SubscribeRequest) GetSeq() uint32 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *SubscribeRequest) GetGen() uint32 {
	if m != nil {
		return m.Gen
	}
	return 0
}

func (m *SubscribeRequest) GetEpoch() string {
	if m != nil {
		return m.Epoch
	}
	return ""
}

func (m *SubscribeRequest) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type SubscribeResult struct {
	Expires      bool           `protobuf:"varint,1,opt,name=expires,proto3" json:"expires,omitempty"`
	TTL          uint32         `protobuf:"varint,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
	Recoverable  bool           `protobuf:"varint,3,opt,name=recoverable,proto3" json:"recoverable,omitempty"`
	Seq          uint32         `protobuf:"varint,4,opt,name=seq,proto3" json:"seq,omitempty"`
	Gen          uint32         `protobuf:"varint,5,opt,name=gen,proto3" json:"gen,omitempty"`
	Epoch        string         `protobuf:"bytes,6,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Publications []*Publication `protobuf:"bytes,7,rep,name=publications,proto3" json:"publications,omitempty"`
	Recovered    bool           `protobuf:"varint,8,opt,name=recovered,proto3" json:"recovered,omitempty"`
	Offset       uint64         `protobuf:"varint,9,opt,name=offset,proto3" json:"offset,omitempty"`
	Positioned   bool           `protobuf:"varint,10,opt,name=positioned,proto3" json:"positioned,omitempty"`
}

func (m *SubscribeResult) Reset()         { *m = SubscribeResult{} }
func (m *SubscribeResult) String() string { return proto.CompactTextString(m) }
func (*SubscribeResult) ProtoMessage()    {}
func (*SubscribeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{16}
}
func (m *SubscribeResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubscribeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubscribeResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubscribeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeResult.Merge(m, src)
}
func (m *SubscribeResult) XXX_Size() int {
	return m.Size()
}
func (m *SubscribeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeResult.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeResult proto.InternalMessageInfo

func (m *SubscribeResult) GetExpires() bool {
	if m != nil {
		return m.Expires
	}
	return false
}

func (m *SubscribeResult) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

func (m *SubscribeResult) GetRecoverable() bool {
	if m != nil {
		return m.Recoverable
	}
	return false
}

func (m *SubscribeResult) GetSeq() uint32 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *SubscribeResult) GetGen() uint32 {
	if m != nil {
		return m.Gen
	}
	return 0
}

func (m *SubscribeResult) GetEpoch() string {
	if m != nil {
		return m.Epoch
	}
	return ""
}

func (m *SubscribeResult) GetPublications() []*Publication {
	if m != nil {
		return m.Publications
	}
	return nil
}

func (m *SubscribeResult) GetRecovered() bool {
	if m != nil {
		return m.Recovered
	}
	return false
}

func (m *SubscribeResult) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *SubscribeResult) GetPositioned() bool {
	if m != nil {
		return m.Positioned
	}
	return false
}

type SubRefreshRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
	Token   string `protobuf:"bytes,2,opt,name=token,proto3" json:"token"`
}

func (m *SubRefreshRequest) Reset()         { *m = SubRefreshRequest{} }
func (m *SubRefreshRequest) String() string { return proto.CompactTextString(m) }
func (*SubRefreshRequest) ProtoMessage()    {}
func (*SubRefreshRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{17}
}
func (m *SubRefreshRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubRefreshRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubRefreshRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubRefreshRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubRefreshRequest.Merge(m, src)
}
func (m *SubRefreshRequest) XXX_Size() int {
	return m.Size()
}
func (m *SubRefreshRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SubRefreshRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SubRefreshRequest proto.InternalMessageInfo

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

func (m *SubRefreshRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

type SubRefreshResult struct {
	Expires bool   `protobuf:"varint,1,opt,name=expires,proto3" json:"expires,omitempty"`
	TTL     uint32 `protobuf:"varint,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
}

func (m *SubRefreshResult) Reset()         { *m = SubRefreshResult{} }
func (m *SubRefreshResult) String() string { return proto.CompactTextString(m) }
func (*SubRefreshResult) ProtoMessage()    {}
func (*SubRefreshResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{18}
}
func (m *SubRefreshResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubRefreshResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubRefreshResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubRefreshResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubRefreshResult.Merge(m, src)
}
func (m *SubRefreshResult) XXX_Size() int {
	return m.Size()
}
func (m *SubRefreshResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SubRefreshResult.DiscardUnknown(m)
}

var xxx_messageInfo_SubRefreshResult proto.InternalMessageInfo

func (m *SubRefreshResult) GetExpires() bool {
	if m != nil {
		return m.Expires
	}
	return false
}

func (m *SubRefreshResult) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

type UnsubscribeRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
}

func (m *UnsubscribeRequest) Reset()         { *m = UnsubscribeRequest{} }
func (m *UnsubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeRequest) ProtoMessage()    {}
func (*UnsubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{19}
}
func (m *UnsubscribeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnsubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnsubscribeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnsubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnsubscribeRequest.Merge(m, src)
}
func (m *UnsubscribeRequest) XXX_Size() int {
	return m.Size()
}
func (m *UnsubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UnsubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UnsubscribeRequest proto.InternalMessageInfo

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

type UnsubscribeResult struct {
}

func (m *UnsubscribeResult) Reset()         { *m = UnsubscribeResult{} }
func (m *UnsubscribeResult) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeResult) ProtoMessage()    {}
func (*UnsubscribeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{20}
}
func (m *UnsubscribeResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnsubscribeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnsubscribeResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnsubscribeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnsubscribeResult.Merge(m, src)
}
func (m *UnsubscribeResult) XXX_Size() int {
	return m.Size()
}
func (m *UnsubscribeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_UnsubscribeResult.DiscardUnknown(m)
}

var xxx_messageInfo_UnsubscribeResult proto.InternalMessageInfo

type PublishRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
	Data    Raw    `protobuf:"bytes,2,opt,name=data,proto3,customtype=Raw" json:"data"`
}

func (m *PublishRequest) Reset()         { *m = PublishRequest{} }
func (m *PublishRequest) String() string { return proto.CompactTextString(m) }
func (*PublishRequest) ProtoMessage()    {}
func (*PublishRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{21}
}
func (m *PublishRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PublishRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PublishRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PublishRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishRequest.Merge(m, src)
}
func (m *PublishRequest) XXX_Size() int {
	return m.Size()
}
func (m *PublishRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PublishRequest proto.InternalMessageInfo

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

type PublishResult struct {
}

func (m *PublishResult) Reset()         { *m = PublishResult{} }
func (m *PublishResult) String() string { return proto.CompactTextString(m) }
func (*PublishResult) ProtoMessage()    {}
func (*PublishResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{22}
}
func (m *PublishResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PublishResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PublishResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PublishResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishResult.Merge(m, src)
}
func (m *PublishResult) XXX_Size() int {
	return m.Size()
}
func (m *PublishResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishResult.DiscardUnknown(m)
}

var xxx_messageInfo_PublishResult proto.InternalMessageInfo

type PresenceRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
}

func (m *PresenceRequest) Reset()         { *m = PresenceRequest{} }
func (m *PresenceRequest) String() string { return proto.CompactTextString(m) }
func (*PresenceRequest) ProtoMessage()    {}
func (*PresenceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{23}
}
func (m *PresenceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PresenceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PresenceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PresenceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PresenceRequest.Merge(m, src)
}
func (m *PresenceRequest) XXX_Size() int {
	return m.Size()
}
func (m *PresenceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PresenceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PresenceRequest proto.InternalMessageInfo

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

type PresenceResult struct {
	Presence map[string]*ClientInfo `protobuf:"bytes,1,rep,name=presence,proto3" json:"presence" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *PresenceResult) Reset()         { *m = PresenceResult{} }
func (m *PresenceResult) String() string { return proto.CompactTextString(m) }
func (*PresenceResult) ProtoMessage()    {}
func (*PresenceResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{24}
}
func (m *PresenceResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PresenceResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PresenceResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PresenceResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PresenceResult.Merge(m, src)
}
func (m *PresenceResult) XXX_Size() int {
	return m.Size()
}
func (m *PresenceResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PresenceResult.DiscardUnknown(m)
}

var xxx_messageInfo_PresenceResult proto.InternalMessageInfo

func (m *PresenceResult) GetPresence() map[string]*ClientInfo {
	if m != nil {
		return m.Presence
	}
	return nil
}

type PresenceStatsRequest struct {
	Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
}

func (m *PresenceStatsRequest) Reset()         { *m = PresenceStatsRequest{} }
func (m *PresenceStatsRequest) String() string { return proto.CompactTextString(m) }
func (*PresenceStatsRequest) ProtoMessage()    {}
func (*PresenceStatsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{25}
}
func (m *PresenceStatsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PresenceStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PresenceStatsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PresenceStatsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PresenceStatsRequest.Merge(m, src)
}
func (m *PresenceStatsRequest) XXX_Size() int {
	return m.Size()
}
func (m *PresenceStatsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PresenceStatsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PresenceStatsRequest proto.InternalMessageInfo

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

type PresenceStatsResult struct {
	NumClients uint32 `protobuf:"varint,1,opt,name=num_clients,json=numClients,proto3" json:"num_clients"`
	NumUsers   uint32 `protobuf:"varint,2,opt,name=num_users,json=numUsers,proto3" json:"num_users"`
}

func (m *PresenceStatsResult) Reset()         { *m = PresenceStatsResult{} }
func (m *PresenceStatsResult) String() string { return proto.CompactTextString(m) }
func (*PresenceStatsResult) ProtoMessage()    {}
func (*PresenceStatsResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{26}
}
func (m *PresenceStatsResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PresenceStatsResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PresenceStatsResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PresenceStatsResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PresenceStatsResult.Merge(m, src)
}
func (m *PresenceStatsResult) XXX_Size() int {
	return m.Size()
}
func (m *PresenceStatsResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PresenceStatsResult.DiscardUnknown(m)
}

var xxx_messageInfo_PresenceStatsResult proto.InternalMessageInfo

func (m *PresenceStatsResult) GetNumClients() uint32 {
	if m != nil {
		return m.NumClients
	}
	return 0
}

func (m *PresenceStatsResult) GetNumUsers() uint32 {
	if m != nil {
		return m.NumUsers
	}
	return 0
}

type HistoryRequest struct {
	Channel  string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
	UseSince bool   `protobuf:"varint,2,opt,name=use_since,json=useSince,proto3" json:"use_since,omitempty"`
	Offset   uint64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Epoch    string `protobuf:"bytes,4,opt,name=epoch,proto3" json:"epoch,omitempty"`
	UseLimit bool   `protobuf:"varint,5,opt,name=use_limit,json=useLimit,proto3" json:"use_limit,omitempty"`
	Limit    int32  `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
}

func (m *HistoryRequest) Reset()         { *m = HistoryRequest{} }
func (m *HistoryRequest) String() string { return proto.CompactTextString(m) }
func (*HistoryRequest) ProtoMessage()    {}
func (*HistoryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{27}
}
func (m *HistoryRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HistoryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HistoryRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HistoryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HistoryRequest.Merge(m, src)
}
func (m *HistoryRequest) XXX_Size() int {
	return m.Size()
}
func (m *HistoryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HistoryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HistoryRequest proto.InternalMessageInfo

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

func (m *HistoryRequest) GetUseSince() bool {
	if m != nil {
		return m.UseSince
	}
	return false
}

func (m *HistoryRequest) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *HistoryRequest) GetEpoch() string {
	if m != nil {
		return m.Epoch
	}
	return ""
}

func (m *HistoryRequest) GetUseLimit() bool {
	if m != nil {
		return m.UseLimit
	}
	return false
}

func (m *HistoryRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type HistoryResult struct {
	Publications []*Publication `protobuf:"bytes,1,rep,name=publications,proto3" json:"publications"`
	Epoch        string         `protobuf:"bytes,2,opt,name=epoch,proto3" json:"epoch"`
	Offset       uint64         `protobuf:"varint,3,opt,name=offset,proto3" json:"offset"`
}

func (m *HistoryResult) Reset()         { *m = HistoryResult{} }
func (m *HistoryResult) String() string { return proto.CompactTextString(m) }
func (*HistoryResult) ProtoMessage()    {}
func (*HistoryResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{28}
}
func (m *HistoryResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HistoryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HistoryResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HistoryResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HistoryResult.Merge(m, src)
}
func (m *HistoryResult) XXX_Size() int {
	return m.Size()
}
func (m *HistoryResult) XXX_DiscardUnknown() {
	xxx_messageInfo_HistoryResult.DiscardUnknown(m)
}

var xxx_messageInfo_HistoryResult proto.InternalMessageInfo

func (m *HistoryResult) GetPublications() []*Publication {
	if m != nil {
		return m.Publications
	}
	return nil
}

func (m *HistoryResult) GetEpoch() string {
	if m != nil {
		return m.Epoch
	}
	return ""
}

func (m *HistoryResult) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type PingRequest struct {
}

func (m *PingRequest) Reset()         { *m = PingRequest{} }
func (m *PingRequest) String() string { return proto.CompactTextString(m) }
func (*PingRequest) ProtoMessage()    {}
func (*PingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{29}
}
func (m *PingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PingRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingRequest.Merge(m, src)
}
func (m *PingRequest) XXX_Size() int {
	return m.Size()
}
func (m *PingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PingRequest proto.InternalMessageInfo

type PingResult struct {
}

func (m *PingResult) Reset()         { *m = PingResult{} }
func (m *PingResult) String() string { return proto.CompactTextString(m) }
func (*PingResult) ProtoMessage()    {}
func (*PingResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{30}
}
func (m *PingResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PingResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PingResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PingResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingResult.Merge(m, src)
}
func (m *PingResult) XXX_Size() int {
	return m.Size()
}
func (m *PingResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PingResult.DiscardUnknown(m)
}

var xxx_messageInfo_PingResult proto.InternalMessageInfo

type RPCRequest struct {
	Data   Raw    `protobuf:"bytes,1,opt,name=data,proto3,customtype=Raw" json:"data"`
	Method string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
}

func (m *RPCRequest) Reset()         { *m = RPCRequest{} }
func (m *RPCRequest) String() string { return proto.CompactTextString(m) }
func (*RPCRequest) ProtoMessage()    {}
func (*RPCRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{31}
}
func (m *RPCRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RPCRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RPCRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RPCRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RPCRequest.Merge(m, src)
}
func (m *RPCRequest) XXX_Size() int {
	return m.Size()
}
func (m *RPCRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RPCRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RPCRequest proto.InternalMessageInfo

func (m *RPCRequest) GetMethod() string {
	if m != nil {
		return m.Method
	}
	return ""
}

type RPCResult struct {
	Data Raw `protobuf:"bytes,1,opt,name=data,proto3,customtype=Raw" json:"data,omitempty"`
}

func (m *RPCResult) Reset()         { *m = RPCResult{} }
func (m *RPCResult) String() string { return proto.CompactTextString(m) }
func (*RPCResult) ProtoMessage()    {}
func (*RPCResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{32}
}
func (m *RPCResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RPCResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RPCResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RPCResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RPCResult.Merge(m, src)
}
func (m *RPCResult) XXX_Size() int {
	return m.Size()
}
func (m *RPCResult) XXX_DiscardUnknown() {
	xxx_messageInfo_RPCResult.DiscardUnknown(m)
}

var xxx_messageInfo_RPCResult proto.InternalMessageInfo

type SendRequest struct {
	Data Raw `protobuf:"bytes,1,opt,name=data,proto3,customtype=Raw" json:"data"`
}

func (m *SendRequest) Reset()         { *m = SendRequest{} }
func (m *SendRequest) String() string { return proto.CompactTextString(m) }
func (*SendRequest) ProtoMessage()    {}
func (*SendRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_014de31d7ac8c57c, []int{33}
}
func (m *SendRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SendRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SendRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendRequest.Merge(m, src)
}
func (m *SendRequest) XXX_Size() int {
	return m.Size()
}
func (m *SendRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SendRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SendRequest proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("protocol.MethodType", MethodType_name, MethodType_value)
	proto.RegisterEnum("protocol.PushType", PushType_name, PushType_value)
	proto.RegisterType((*Error)(nil), "protocol.Error")
	proto.RegisterType((*Command)(nil), "protocol.Command")
	proto.RegisterType((*Reply)(nil), "protocol.Reply")
	proto.RegisterType((*Push)(nil), "protocol.Push")
	proto.RegisterType((*ClientInfo)(nil), "protocol.ClientInfo")
	proto.RegisterType((*Publication)(nil), "protocol.Publication")
	proto.RegisterType((*Join)(nil), "protocol.Join")
	proto.RegisterType((*Leave)(nil), "protocol.Leave")
	proto.RegisterType((*Unsub)(nil), "protocol.Unsub")
	proto.RegisterType((*Sub)(nil), "protocol.Sub")
	proto.RegisterType((*Message)(nil), "protocol.Message")
	proto.RegisterType((*ConnectRequest)(nil), "protocol.ConnectRequest")
	proto.RegisterMapType((map[string]*SubscribeRequest)(nil), "protocol.ConnectRequest.SubsEntry")
	proto.RegisterType((*ConnectResult)(nil), "protocol.ConnectResult")
	proto.RegisterMapType((map[string]*SubscribeResult)(nil), "protocol.ConnectResult.SubsEntry")
	proto.RegisterType((*RefreshRequest)(nil), "protocol.RefreshRequest")
	proto.RegisterType((*RefreshResult)(nil), "protocol.RefreshResult")
	proto.RegisterType((*SubscribeRequest)(nil), "protocol.SubscribeRequest")
	proto.RegisterType((*SubscribeResult)(nil), "protocol.SubscribeResult")
	proto.RegisterType((*SubRefreshRequest)(nil), "protocol.SubRefreshRequest")
	proto.RegisterType((*SubRefreshResult)(nil), "protocol.SubRefreshResult")
	proto.RegisterType((*UnsubscribeRequest)(nil), "protocol.UnsubscribeRequest")
	proto.RegisterType((*UnsubscribeResult)(nil), "protocol.UnsubscribeResult")
	proto.RegisterType((*PublishRequest)(nil), "protocol.PublishRequest")
	proto.RegisterType((*PublishResult)(nil), "protocol.PublishResult")
	proto.RegisterType((*PresenceRequest)(nil), "protocol.PresenceRequest")
	proto.RegisterType((*PresenceResult)(nil), "protocol.PresenceResult")
	proto.RegisterMapType((map[string]*ClientInfo)(nil), "protocol.PresenceResult.PresenceEntry")
	proto.RegisterType((*PresenceStatsRequest)(nil), "protocol.PresenceStatsRequest")
	proto.RegisterType((*PresenceStatsResult)(nil), "protocol.PresenceStatsResult")
	proto.RegisterType((*HistoryRequest)(nil), "protocol.HistoryRequest")
	proto.RegisterType((*HistoryResult)(nil), "protocol.HistoryResult")
	proto.RegisterType((*PingRequest)(nil), "protocol.PingRequest")
	proto.RegisterType((*PingResult)(nil), "protocol.PingResult")
	proto.RegisterType((*RPCRequest)(nil), "protocol.RPCRequest")
	proto.RegisterType((*RPCResult)(nil), "protocol.RPCResult")
	proto.RegisterType((*SendRequest)(nil), "protocol.SendRequest")
}

func init() { proto.RegisterFile("client.proto", fileDescriptor_014de31d7ac8c57c) }

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

func (this *Error) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Error)
	if !ok {
		that2, ok := that.(Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Code != that1.Code {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *Command) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Command)
	if !ok {
		that2, ok := that.(Command)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Method != that1.Method {
		return false
	}
	if !this.Params.Equal(that1.Params) {
		return false
	}
	return true
}
func (this *Reply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Reply)
	if !ok {
		that2, ok := that.(Reply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	if !this.Result.Equal(that1.Result) {
		return false
	}
	return true
}
func (this *Push) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Push)
	if !ok {
		that2, ok := that.(Push)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *ClientInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ClientInfo)
	if !ok {
		that2, ok := that.(ClientInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.User != that1.User {
		return false
	}
	if this.Client != that1.Client {
		return false
	}
	if !this.ConnInfo.Equal(that1.ConnInfo) {
		return false
	}
	if !this.ChanInfo.Equal(that1.ChanInfo) {
		return false
	}
	return true
}
func (this *Publication) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Publication)
	if !ok {
		that2, ok := that.(Publication)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Seq != that1.Seq {
		return false
	}
	if this.Gen != that1.Gen {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	if !this.Info.Equal(that1.Info) {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	return true
}
func (this *Join) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Join)
	if !ok {
		that2, ok := that.(Join)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Info.Equal(&that1.Info) {
		return false
	}
	return true
}
func (this *Leave) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Leave)
	if !ok {
		that2, ok := that.(Leave)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Info.Equal(&that1.Info) {
		return false
	}
	return true
}
func (this *Unsub) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Unsub)
	if !ok {
		that2, ok := that.(Unsub)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Resubscribe != that1.Resubscribe {
		return false
	}
	return true
}
func (this *Sub) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Sub)
	if !ok {
		that2, ok := that.(Sub)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Recoverable != that1.Recoverable {
		return false
	}
	if this.Seq != that1.Seq {
		return false
	}
	if this.Gen != that1.Gen {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Positioned != that1.Positioned {
		return false
	}
	return true
}
func (this *Message) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Message)
	if !ok {
		that2, ok := that.(Message)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *ConnectRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConnectRequest)
	if !ok {
		that2, ok := that.(ConnectRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	if len(this.Subs) != len(that1.Subs) {
		return false
	}
	for i := range this.Subs {
		if !this.Subs[i].Equal(that1.Subs[i]) {
			return false
		}
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	return true
}
func (this *ConnectResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConnectResult)
	if !ok {
		that2, ok := that.(ConnectResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Client != that1.Client {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if this.Expires != that1.Expires {
		return false
	}
	if this.TTL != that1.TTL {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	if len(this.Subs) != len(that1.Subs) {
		return false
	}
	for i := range this.Subs {
		if !this.Subs[i].Equal(that1.Subs[i]) {
			return false
		}
	}
	return true
}
func (this *RefreshRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RefreshRequest)
	if !ok {
		that2, ok := that.(RefreshRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	return true
}
func (this *RefreshResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RefreshResult)
	if !ok {
		that2, ok := that.(RefreshResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Client != that1.Client {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if this.Expires != that1.Expires {
		return false
	}
	if this.TTL != that1.TTL {
		return false
	}
	return true
}
func (this *SubscribeRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SubscribeRequest)
	if !ok {
		that2, ok := that.(SubscribeRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	if this.Recover != that1.Recover {
		return false
	}
	if this.Seq != that1.Seq {
		return false
	}
	if this.Gen != that1.Gen {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	return true
}
func (this *SubscribeResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SubscribeResult)
	if !ok {
		that2, ok := that.(SubscribeResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Expires != that1.Expires {
		return false
	}
	if this.TTL != that1.TTL {
		return false
	}
	if this.Recoverable != that1.Recoverable {
		return false
	}
	if this.Seq != that1.Seq {
		return false
	}
	if this.Gen != that1.Gen {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if len(this.Publications) != len(that1.Publications) {
		return false
	}
	for i := range this.Publications {
		if !this.Publications[i].Equal(that1.Publications[i]) {
			return false
		}
	}
	if this.Recovered != that1.Recovered {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Positioned != that1.Positioned {
		return false
	}
	return true
}
func (this *SubRefreshRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SubRefreshRequest)
	if !ok {
		that2, ok := that.(SubRefreshRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	return true
}
func (this *SubRefreshResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SubRefreshResult)
	if !ok {
		that2, ok := that.(SubRefreshResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Expires != that1.Expires {
		return false
	}
	if this.TTL != that1.TTL {
		return false
	}
	return true
}
func (this *UnsubscribeRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UnsubscribeRequest)
	if !ok {
		that2, ok := that.(UnsubscribeRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	return true
}
func (this *UnsubscribeResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UnsubscribeResult)
	if !ok {
		that2, ok := that.(UnsubscribeResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *PublishRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PublishRequest)
	if !ok {
		that2, ok := that.(PublishRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *PublishResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PublishResult)
	if !ok {
		that2, ok := that.(PublishResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *PresenceRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PresenceRequest)
	if !ok {
		that2, ok := that.(PresenceRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	return true
}
func (this *PresenceResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PresenceResult)
	if !ok {
		that2, ok := that.(PresenceResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Presence) != len(that1.Presence) {
		return false
	}
	for i := range this.Presence {
		if !this.Presence[i].Equal(that1.Presence[i]) {
			return false
		}
	}
	return true
}
func (this *PresenceStatsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PresenceStatsRequest)
	if !ok {
		that2, ok := that.(PresenceStatsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	return true
}
func (this *PresenceStatsResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PresenceStatsResult)
	if !ok {
		that2, ok := that.(PresenceStatsResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NumClients != that1.NumClients {
		return false
	}
	if this.NumUsers != that1.NumUsers {
		return false
	}
	return true
}
func (this *HistoryRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HistoryRequest)
	if !ok {
		that2, ok := that.(HistoryRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Channel != that1.Channel {
		return false
	}
	if this.UseSince != that1.UseSince {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.UseLimit != that1.UseLimit {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	return true
}
func (this *HistoryResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HistoryResult)
	if !ok {
		that2, ok := that.(HistoryResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Publications) != len(that1.Publications) {
		return false
	}
	for i := range this.Publications {
		if !this.Publications[i].Equal(that1.Publications[i]) {
			return false
		}
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	return true
}
func (this *PingRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PingRequest)
	if !ok {
		that2, ok := that.(PingRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *PingResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PingResult)
	if !ok {
		that2, ok := that.(PingResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *RPCRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RPCRequest)
	if !ok {
		that2, ok := that.(RPCRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	if this.Method != that1.Method {
		return false
	}
	return true
}
func (this *RPCResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RPCResult)
	if !ok {
		that2, ok := that.(RPCResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *SendRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SendRequest)
	if !ok {
		that2, ok := that.(SendRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (m *Error) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Error) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Command) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Command) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Command) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Params.Size()
		i -= size
		if _, err := m.Params.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Method != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Reply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Reply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Result.Size()
		i -= size
		if _, err := m.Result.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintClient(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Push) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Push) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Push) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ClientInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ClientInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClientInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ChanInfo.Size()
		i -= size
		if _, err := m.ChanInfo.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.ConnInfo.Size()
		i -= size
		if _, err := m.ConnInfo.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Client) > 0 {
		i -= len(m.Client)
		copy(dAtA[i:], m.Client)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Client)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintClient(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Publication) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Publication) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Publication) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x30
	}
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintClient(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintClient(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Gen != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Gen))
		i--
		dAtA[i] = 0x10
	}
	if m.Seq != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Join) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Join) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Join) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Leave) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Leave) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Leave) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Unsub) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Unsub) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Unsub) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Resubscribe {
		i--
		if m.Resubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Sub) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sub) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Sub) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Positioned {
		i--
		if m.Positioned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Epoch) > 0 {
		i -= len(m.Epoch)
		copy(dAtA[i:], m.Epoch)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Epoch)))
		i--
		dAtA[i] = 0x22
	}
	if m.Gen != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Gen))
		i--
		dAtA[i] = 0x18
	}
	if m.Seq != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x10
	}
	if m.Recoverable {
		i--
		if m.Recoverable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Message) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Message) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ConnectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Subs) > 0 {
		for k := range m.Subs {
			v := m.Subs[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintClient(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintClient(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintClient(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConnectResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnectResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnectResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Subs) > 0 {
		for k := range m.Subs {
			v := m.Subs[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintClient(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintClient(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintClient(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.TTL != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x20
	}
	if m.Expires {
		i--
		if m.Expires {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Client) > 0 {
		i -= len(m.Client)
		copy(dAtA[i:], m.Client)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Client)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RefreshRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RefreshRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RefreshRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RefreshResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RefreshResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RefreshResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TTL != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x20
	}
	if m.Expires {
		i--
		if m.Expires {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Client) > 0 {
		i -= len(m.Client)
		copy(dAtA[i:], m.Client)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Client)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Epoch) > 0 {
		i -= len(m.Epoch)
		copy(dAtA[i:], m.Epoch)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Epoch)))
		i--
		dAtA[i] = 0x32
	}
	if m.Gen != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Gen))
		i--
		dAtA[i] = 0x28
	}
	if m.Seq != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x20
	}
	if m.Recover {
		i--
		if m.Recover {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SubscribeResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubscribeResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubscribeResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Positioned {
		i--
		if m.Positioned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x48
	}
	if m.Recovered {
		i--
		if m.Recovered {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Publications) > 0 {
		for iNdEx := len(m.Publications) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Publications[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintClient(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Epoch) > 0 {
		i -= len(m.Epoch)
		copy(dAtA[i:], m.Epoch)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Epoch)))
		i--
		dAtA[i] = 0x32
	}
	if m.Gen != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Gen))
		i--
		dAtA[i] = 0x28
	}
	if m.Seq != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x20
	}
	if m.Recoverable {
		i--
		if m.Recoverable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.TTL != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x10
	}
	if m.Expires {
		i--
		if m.Expires {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SubRefreshRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubRefreshRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubRefreshRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SubRefreshResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubRefreshResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubRefreshResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TTL != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x10
	}
	if m.Expires {
		i--
		if m.Expires {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UnsubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnsubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnsubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnsubscribeResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnsubscribeResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnsubscribeResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *PublishRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PublishRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PublishRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PublishResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PublishResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PublishResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *PresenceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PresenceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PresenceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PresenceResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PresenceResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PresenceResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Presence) > 0 {
		for k := range m.Presence {
			v := m.Presence[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintClient(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintClient(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintClient(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PresenceStatsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PresenceStatsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PresenceStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PresenceStatsResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PresenceStatsResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PresenceStatsResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumUsers != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.NumUsers))
		i--
		dAtA[i] = 0x10
	}
	if m.NumClients != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.NumClients))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HistoryRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HistoryRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HistoryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Limit != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x30
	}
	if m.UseLimit {
		i--
		if m.UseLimit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Epoch) > 0 {
		i -= len(m.Epoch)
		copy(dAtA[i:], m.Epoch)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Epoch)))
		i--
		dAtA[i] = 0x22
	}
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x18
	}
	if m.UseSince {
		i--
		if m.UseSince {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HistoryResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HistoryResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HistoryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Offset != 0 {
		i = encodeVarintClient(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Epoch) > 0 {
		i -= len(m.Epoch)
		copy(dAtA[i:], m.Epoch)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Epoch)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Publications) > 0 {
		for iNdEx := len(m.Publications) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Publications[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintClient(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PingRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *PingResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PingResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PingResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RPCRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RPCRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RPCRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Method) > 0 {
		i -= len(m.Method)
		copy(dAtA[i:], m.Method)
		i = encodeVarintClient(dAtA, i, uint64(len(m.Method)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *RPCResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RPCResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RPCResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *SendRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SendRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SendRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintClient(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintClient(dAtA []byte, offset int, v uint64) int {
	offset -= sovClient(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedError(r randyClient, easy bool) *Error {
	this := &Error{}
	this.Code = uint32(r.Uint32())
	this.Message = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCommand(r randyClient, easy bool) *Command {
	this := &Command{}
	this.ID = uint32(r.Uint32())
	this.Method = MethodType([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(12)])
	v1 := NewPopulatedRaw(r)
	this.Params = *v1
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedReply(r randyClient, easy bool) *Reply {
	this := &Reply{}
	this.ID = uint32(r.Uint32())
	if r.Intn(5) != 0 {
		this.Error = NewPopulatedError(r, easy)
	}
	v2 := NewPopulatedRaw(r)
	this.Result = *v2
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPush(r randyClient, easy bool) *Push {
	this := &Push{}
	this.Type = PushType([]int32{0, 1, 2, 3, 4, 5}[r.Intn(6)])
	this.Channel = string(randStringClient(r))
	v3 := NewPopulatedRaw(r)
	this.Data = *v3
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedClientInfo(r randyClient, easy bool) *ClientInfo {
	this := &ClientInfo{}
	this.User = string(randStringClient(r))
	this.Client = string(randStringClient(r))
	v4 := NewPopulatedRaw(r)
	this.ConnInfo = *v4
	v5 := NewPopulatedRaw(r)
	this.ChanInfo = *v5
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPublication(r randyClient, easy bool) *Publication {
	this := &Publication{}
	this.Seq = uint32(r.Uint32())
	this.Gen = uint32(r.Uint32())
	this.UID = string(randStringClient(r))
	v6 := NewPopulatedRaw(r)
	this.Data = *v6
	if r.Intn(5) != 0 {
		this.Info = NewPopulatedClientInfo(r, easy)
	}
	this.Offset = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedJoin(r randyClient, easy bool) *Join {
	this := &Join{}
	v7 := NewPopulatedClientInfo(r, easy)
	this.Info = *v7
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedLeave(r randyClient, easy bool) *Leave {
	this := &Leave{}
	v8 := NewPopulatedClientInfo(r, easy)
	this.Info = *v8
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedUnsub(r randyClient, easy bool) *Unsub {
	this := &Unsub{}
	this.Resubscribe = bool(bool(r.Intn(2) == 0))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSub(r randyClient, easy bool) *Sub {
	this := &Sub{}
	this.Recoverable = bool(bool(r.Intn(2) == 0))
	this.Seq = uint32(r.Uint32())
	this.Gen = uint32(r.Uint32())
	this.Epoch = string(randStringClient(r))
	this.Offset = uint64(uint64(r.Uint32()))
	this.Positioned = bool(bool(r.Intn(2) == 0))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMessage(r randyClient, easy bool) *Message {
	this := &Message{}
	v9 := NewPopulatedRaw(r)
	this.Data = *v9
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedConnectRequest(r randyClient, easy bool) *ConnectRequest {
	this := &ConnectRequest{}
	this.Token = string(randStringClient(r))
	v10 := NewPopulatedRaw(r)
	this.Data = *v10
	if r.Intn(5) != 0 {
		v11 := r.Intn(10)
		this.Subs = make(map[string]*SubscribeRequest)
		for i := 0; i < v11; i++ {
			this.Subs[randStringClient(r)] = NewPopulatedSubscribeRequest(r, easy)
		}
	}
	this.Name = string(randStringClient(r))
	this.Version = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedConnectResult(r randyClient, easy bool) *ConnectResult {
	this := &ConnectResult{}
	this.Client = string(randStringClient(r))
	this.Version = string(randStringClient(r))
	this.Expires = bool(bool(r.Intn(2) == 0))
	this.TTL = uint32(r.Uint32())
	v12 := NewPopulatedRaw(r)
	this.Data = *v12
	if r.Intn(5) != 0 {
		v13 := r.Intn(10)
		this.Subs = make(map[string]*SubscribeResult)
		for i := 0; i < v13; i++ {
			this.Subs[randStringClient(r)] = NewPopulatedSubscribeResult(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRefreshRequest(r randyClient, easy bool) *RefreshRequest {
	this := &RefreshRequest{}
	this.Token = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRefreshResult(r randyClient, easy bool) *RefreshResult {
	this := &RefreshResult{}
	this.Client = string(randStringClient(r))
	this.Version = string(randStringClient(r))
	this.Expires = bool(bool(r.Intn(2) == 0))
	this.TTL = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSubscribeRequest(r randyClient, easy bool) *SubscribeRequest {
	this := &SubscribeRequest{}
	this.Channel = string(randStringClient(r))
	this.Token = string(randStringClient(r))
	this.Recover = bool(bool(r.Intn(2) == 0))
	this.Seq = uint32(r.Uint32())
	this.Gen = uint32(r.Uint32())
	this.Epoch = string(randStringClient(r))
	this.Offset = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSubscribeResult(r randyClient, easy bool) *SubscribeResult {
	this := &SubscribeResult{}
	this.Expires = bool(bool(r.Intn(2) == 0))
	this.TTL = uint32(r.Uint32())
	this.Recoverable = bool(bool(r.Intn(2) == 0))
	this.Seq = uint32(r.Uint32())
	this.Gen = uint32(r.Uint32())
	this.Epoch = string(randStringClient(r))
	if r.Intn(5) != 0 {
		v14 := r.Intn(5)
		this.Publications = make([]*Publication, v14)
		for i := 0; i < v14; i++ {
			this.Publications[i] = NewPopulatedPublication(r, easy)
		}
	}
	this.Recovered = bool(bool(r.Intn(2) == 0))
	this.Offset = uint64(uint64(r.Uint32()))
	this.Positioned = bool(bool(r.Intn(2) == 0))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSubRefreshRequest(r randyClient, easy bool) *SubRefreshRequest {
	this := &SubRefreshRequest{}
	this.Channel = string(randStringClient(r))
	this.Token = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSubRefreshResult(r randyClient, easy bool) *SubRefreshResult {
	this := &SubRefreshResult{}
	this.Expires = bool(bool(r.Intn(2) == 0))
	this.TTL = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedUnsubscribeRequest(r randyClient, easy bool) *UnsubscribeRequest {
	this := &UnsubscribeRequest{}
	this.Channel = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedUnsubscribeResult(r randyClient, easy bool) *UnsubscribeResult {
	this := &UnsubscribeResult{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPublishRequest(r randyClient, easy bool) *PublishRequest {
	this := &PublishRequest{}
	this.Channel = string(randStringClient(r))
	v15 := NewPopulatedRaw(r)
	this.Data = *v15
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPublishResult(r randyClient, easy bool) *PublishResult {
	this := &PublishResult{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPresenceRequest(r randyClient, easy bool) *PresenceRequest {
	this := &PresenceRequest{}
	this.Channel = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPresenceResult(r randyClient, easy bool) *PresenceResult {
	this := &PresenceResult{}
	if r.Intn(5) != 0 {
		v16 := r.Intn(10)
		this.Presence = make(map[string]*ClientInfo)
		for i := 0; i < v16; i++ {
			this.Presence[randStringClient(r)] = NewPopulatedClientInfo(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPresenceStatsRequest(r randyClient, easy bool) *PresenceStatsRequest {
	this := &PresenceStatsRequest{}
	this.Channel = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPresenceStatsResult(r randyClient, easy bool) *PresenceStatsResult {
	this := &PresenceStatsResult{}
	this.NumClients = uint32(r.Uint32())
	this.NumUsers = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedHistoryRequest(r randyClient, easy bool) *HistoryRequest {
	this := &HistoryRequest{}
	this.Channel = string(randStringClient(r))
	this.UseSince = bool(bool(r.Intn(2) == 0))
	this.Offset = uint64(uint64(r.Uint32()))
	this.Epoch = string(randStringClient(r))
	this.UseLimit = bool(bool(r.Intn(2) == 0))
	this.Limit = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Limit *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedHistoryResult(r randyClient, easy bool) *HistoryResult {
	this := &HistoryResult{}
	if r.Intn(5) != 0 {
		v17 := r.Intn(5)
		this.Publications = make([]*Publication, v17)
		for i := 0; i < v17; i++ {
			this.Publications[i] = NewPopulatedPublication(r, easy)
		}
	}
	this.Epoch = string(randStringClient(r))
	this.Offset = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPingRequest(r randyClient, easy bool) *PingRequest {
	this := &PingRequest{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPingResult(r randyClient, easy bool) *PingResult {
	this := &PingResult{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRPCRequest(r randyClient, easy bool) *RPCRequest {
	this := &RPCRequest{}
	v18 := NewPopulatedRaw(r)
	this.Data = *v18
	this.Method = string(randStringClient(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRPCResult(r randyClient, easy bool) *RPCResult {
	this := &RPCResult{}
	v19 := NewPopulatedRaw(r)
	this.Data = *v19
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSendRequest(r randyClient, easy bool) *SendRequest {
	this := &SendRequest{}
	v20 := NewPopulatedRaw(r)
	this.Data = *v20
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyClient interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneClient(r randyClient) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringClient(r randyClient) string {
	v21 := r.Intn(100)
	tmps := make([]rune, v21)
	for i := 0; i < v21; i++ {
		tmps[i] = randUTF8RuneClient(r)
	}
	return string(tmps)
}
func randUnrecognizedClient(r randyClient, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldClient(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldClient(dAtA []byte, r randyClient, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateClient(dAtA, uint64(key))
		v22 := r.Int63()
		if r.Intn(2) == 0 {
			v22 *= -1
		}
		dAtA = encodeVarintPopulateClient(dAtA, uint64(v22))
	case 1:
		dAtA = encodeVarintPopulateClient(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateClient(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateClient(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateClient(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateClient(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovClient(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *Command) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovClient(uint64(m.ID))
	}
	if m.Method != 0 {
		n += 1 + sovClient(uint64(m.Method))
	}
	l = m.Params.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovClient(uint64(m.ID))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.Result.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *Push) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovClient(uint64(m.Type))
	}
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *ClientInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Client)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.ConnInfo.Size()
	n += 1 + l + sovClient(uint64(l))
	l = m.ChanInfo.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *Publication) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Seq != 0 {
		n += 1 + sovClient(uint64(m.Seq))
	}
	if m.Gen != 0 {
		n += 1 + sovClient(uint64(m.Gen))
	}
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	return n
}

func (m *Join) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Info.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *Leave) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Info.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *Unsub) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Resubscribe {
		n += 2
	}
	return n
}

func (m *Sub) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Recoverable {
		n += 2
	}
	if m.Seq != 0 {
		n += 1 + sovClient(uint64(m.Seq))
	}
	if m.Gen != 0 {
		n += 1 + sovClient(uint64(m.Gen))
	}
	l = len(m.Epoch)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	if m.Positioned {
		n += 2
	}
	return n
}

func (m *Message) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *ConnectRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	if len(m.Subs) > 0 {
		for k, v := range m.Subs {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovClient(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovClient(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovClient(uint64(mapEntrySize))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *ConnectResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Client)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Expires {
		n += 2
	}
	if m.TTL != 0 {
		n += 1 + sovClient(uint64(m.TTL))
	}
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	if len(m.Subs) > 0 {
		for k, v := range m.Subs {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovClient(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovClient(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovClient(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *RefreshRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *RefreshResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Client)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Expires {
		n += 2
	}
	if m.TTL != 0 {
		n += 1 + sovClient(uint64(m.TTL))
	}
	return n
}

func (m *SubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Recover {
		n += 2
	}
	if m.Seq != 0 {
		n += 1 + sovClient(uint64(m.Seq))
	}
	if m.Gen != 0 {
		n += 1 + sovClient(uint64(m.Gen))
	}
	l = len(m.Epoch)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	return n
}

func (m *SubscribeResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Expires {
		n += 2
	}
	if m.TTL != 0 {
		n += 1 + sovClient(uint64(m.TTL))
	}
	if m.Recoverable {
		n += 2
	}
	if m.Seq != 0 {
		n += 1 + sovClient(uint64(m.Seq))
	}
	if m.Gen != 0 {
		n += 1 + sovClient(uint64(m.Gen))
	}
	l = len(m.Epoch)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if len(m.Publications) > 0 {
		for _, e := range m.Publications {
			l = e.Size()
			n += 1 + l + sovClient(uint64(l))
		}
	}
	if m.Recovered {
		n += 2
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	if m.Positioned {
		n += 2
	}
	return n
}

func (m *SubRefreshRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *SubRefreshResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Expires {
		n += 2
	}
	if m.TTL != 0 {
		n += 1 + sovClient(uint64(m.TTL))
	}
	return n
}

func (m *UnsubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *UnsubscribeResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *PublishRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *PublishResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *PresenceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *PresenceResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Presence) > 0 {
		for k, v := range m.Presence {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovClient(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovClient(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovClient(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *PresenceStatsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *PresenceStatsResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NumClients != 0 {
		n += 1 + sovClient(uint64(m.NumClients))
	}
	if m.NumUsers != 0 {
		n += 1 + sovClient(uint64(m.NumUsers))
	}
	return n
}

func (m *HistoryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.UseSince {
		n += 2
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	l = len(m.Epoch)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.UseLimit {
		n += 2
	}
	if m.Limit != 0 {
		n += 1 + sovClient(uint64(m.Limit))
	}
	return n
}

func (m *HistoryResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Publications) > 0 {
		for _, e := range m.Publications {
			l = e.Size()
			n += 1 + l + sovClient(uint64(l))
		}
	}
	l = len(m.Epoch)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovClient(uint64(m.Offset))
	}
	return n
}

func (m *PingRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *PingResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RPCRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	l = len(m.Method)
	if l > 0 {
		n += 1 + l + sovClient(uint64(l))
	}
	return n
}

func (m *RPCResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func (m *SendRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Data.Size()
	n += 1 + l + sovClient(uint64(l))
	return n
}

func sovClient(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozClient(x uint64) (n int) {
	return sovClient(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Error) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Command) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Command: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Command: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= MethodType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Reply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Reply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Publication) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Publication: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Publication: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gen", wireType)
			}
			m.Gen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &ClientInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Unsub) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Unsub: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Unsub: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resubscribe", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Resubscribe = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sub) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Sub: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sub: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recoverable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Recoverable = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gen", wireType)
			}
			m.Gen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Epoch = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Positioned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Positioned = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnectRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Subs == nil {
				m.Subs = make(map[string]*SubscribeRequest)
			}
			var mapkey string
			var mapvalue *SubscribeRequest
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowClient
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthClient
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthClient
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthClient
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthClient
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &SubscribeRequest{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipClient(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthClient
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Subs[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnectResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Client", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Client = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Expires = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Subs == nil {
				m.Subs = make(map[string]*SubscribeResult)
			}
			var mapkey string
			var mapvalue *SubscribeResult
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowClient
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthClient
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthClient
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthClient
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthClient
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &SubscribeResult{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipClient(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthClient
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Subs[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RefreshResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RefreshResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RefreshResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Client", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Client = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Expires = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubscribeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubscribeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubscribeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Channel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recover", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Recover = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gen", wireType)
			}
			m.Gen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Epoch = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubscribeResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubscribeResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubscribeResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Expires = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recoverable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Recoverable = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gen", wireType)
			}
			m.Gen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Epoch = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Publications", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Publications = append(m.Publications, &Publication{})
			if err := m.Publications[len(m.Publications)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recovered", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Recovered = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Positioned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Positioned = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubRefreshResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubRefreshResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubRefreshResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Expires = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnsubscribeResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnsubscribeResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsubscribeResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PublishResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PublishResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PublishResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PresenceResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PresenceResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PresenceResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Presence", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Presence == nil {
				m.Presence = make(map[string]*ClientInfo)
			}
			var mapkey string
			var mapvalue *ClientInfo
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowClient
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthClient
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthClient
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowClient
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthClient
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthClient
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ClientInfo{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipClient(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthClient
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Presence[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PresenceStatsResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PresenceStatsResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PresenceStatsResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumClients", wireType)
			}
			m.NumClients = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumClients |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumUsers", wireType)
			}
			m.NumUsers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumUsers |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistoryRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HistoryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistoryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Channel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseSince", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseSince = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthClient
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthClient
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Epoch = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseLimit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseLimit = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClient
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PingRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PingResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowClient
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PingResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipClient(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthClient
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipClient(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowClient
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowClient
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowClient
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthClient
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupClient
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthClient
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthClient        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowClient          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupClient = fmt.Errorf("proto: unexpected end of group")
)
