collaborative-text-editor/collabTexteditorService/collabTexteditorService.pb.go

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

package collabTexteditorService

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Empty proto.InternalMessageInfo

type SessionResponse struct {
	SessionId            string   `protobuf:"bytes,1,opt,name=sessionId,proto3" json:"sessionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SessionResponse proto.InternalMessageInfo

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

type JoinSessionRequest struct {
	SessionId            string   `protobuf:"bytes,1,opt,name=sessionId,proto3" json:"sessionId,omitempty"`
	NickName             string   `protobuf:"bytes,2,opt,name=nickName,proto3" json:"nickName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_JoinSessionRequest proto.InternalMessageInfo

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

func (m *JoinSessionRequest) GetNickName() string {
	if m != nil {
		return m.NickName
	}
	return ""
}

type JoinSessionResponse struct {
	ReplicaId            int64    `protobuf:"varint,1,opt,name=replicaId,proto3" json:"replicaId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_JoinSessionResponse proto.InternalMessageInfo

func (m *JoinSessionResponse) GetReplicaId() int64 {
	if m != nil {
		return m.ReplicaId
	}
	return 0
}

type LocalUpdateRequest struct {
	Node                 *TiTreeNode `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	ReplicaId            int64       `protobuf:"varint,2,opt,name=replicaId,proto3" json:"replicaId,omitempty"`
	SessionId            string      `protobuf:"bytes,3,opt,name=sessionId,proto3" json:"sessionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_LocalUpdateRequest proto.InternalMessageInfo

func (m *LocalUpdateRequest) GetNode() *TiTreeNode {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *LocalUpdateRequest) GetReplicaId() int64 {
	if m != nil {
		return m.ReplicaId
	}
	return 0
}

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

type LocalUpdateReply struct {
	StatusMessage        string   `protobuf:"bytes,1,opt,name=statusMessage,proto3" json:"statusMessage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LocalUpdateReply proto.InternalMessageInfo

func (m *LocalUpdateReply) GetStatusMessage() string {
	if m != nil {
		return m.StatusMessage
	}
	return ""
}

type RemoteUpdateRequest struct {
	ReplicaId            int64    `protobuf:"varint,1,opt,name=replicaId,proto3" json:"replicaId,omitempty"`
	SessionId            string   `protobuf:"bytes,2,opt,name=sessionId,proto3" json:"sessionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RemoteUpdateRequest proto.InternalMessageInfo

func (m *RemoteUpdateRequest) GetReplicaId() int64 {
	if m != nil {
		return m.ReplicaId
	}
	return 0
}

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

type RemoteUpdateResponse struct {
	SenderReplicaId      int64       `protobuf:"varint,1,opt,name=senderReplicaId,proto3" json:"senderReplicaId,omitempty"`
	Node                 *TiTreeNode `protobuf:"bytes,2,opt,name=node,proto3" json:"node,omitempty"`
	Nickname             string      `protobuf:"bytes,3,opt,name=nickname,proto3" json:"nickname,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_RemoteUpdateResponse proto.InternalMessageInfo

func (m *RemoteUpdateResponse) GetSenderReplicaId() int64 {
	if m != nil {
		return m.SenderReplicaId
	}
	return 0
}

func (m *RemoteUpdateResponse) GetNode() *TiTreeNode {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *RemoteUpdateResponse) GetNickname() string {
	if m != nil {
		return m.Nickname
	}
	return ""
}

type TiTreeNode struct {
	Timestamp            *TiTreeNode_Timestamp   `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	ParentTimestamp      *TiTreeNode_Timestamp   `protobuf:"bytes,2,opt,name=parentTimestamp,proto3" json:"parentTimestamp,omitempty"`
	Value                string                  `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	Tombstone            bool                    `protobuf:"varint,4,opt,name=tombstone,proto3" json:"tombstone,omitempty"`
	ChildrenTimestamps   []*TiTreeNode_Timestamp `protobuf:"bytes,5,rep,name=childrenTimestamps,proto3" json:"childrenTimestamps,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_TiTreeNode proto.InternalMessageInfo

func (m *TiTreeNode) GetTimestamp() *TiTreeNode_Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *TiTreeNode) GetParentTimestamp() *TiTreeNode_Timestamp {
	if m != nil {
		return m.ParentTimestamp
	}
	return nil
}

func (m *TiTreeNode) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *TiTreeNode) GetTombstone() bool {
	if m != nil {
		return m.Tombstone
	}
	return false
}

func (m *TiTreeNode) GetChildrenTimestamps() []*TiTreeNode_Timestamp {
	if m != nil {
		return m.ChildrenTimestamps
	}
	return nil
}

type TiTreeNode_Timestamp struct {
	ReplicaId            int64    `protobuf:"varint,1,opt,name=replicaId,proto3" json:"replicaId,omitempty"`
	Id                   int64    `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TiTreeNode_Timestamp proto.InternalMessageInfo

func (m *TiTreeNode_Timestamp) GetReplicaId() int64 {
	if m != nil {
		return m.ReplicaId
	}
	return 0
}

func (m *TiTreeNode_Timestamp) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func init() {
	proto.RegisterType((*Empty)(nil), "collabTexteditorService.Empty")
	proto.RegisterType((*SessionResponse)(nil), "collabTexteditorService.SessionResponse")
	proto.RegisterType((*JoinSessionRequest)(nil), "collabTexteditorService.JoinSessionRequest")
	proto.RegisterType((*JoinSessionResponse)(nil), "collabTexteditorService.JoinSessionResponse")
	proto.RegisterType((*LocalUpdateRequest)(nil), "collabTexteditorService.LocalUpdateRequest")
	proto.RegisterType((*LocalUpdateReply)(nil), "collabTexteditorService.LocalUpdateReply")
	proto.RegisterType((*RemoteUpdateRequest)(nil), "collabTexteditorService.RemoteUpdateRequest")
	proto.RegisterType((*RemoteUpdateResponse)(nil), "collabTexteditorService.RemoteUpdateResponse")
	proto.RegisterType((*TiTreeNode)(nil), "collabTexteditorService.TiTreeNode")
	proto.RegisterType((*TiTreeNode_Timestamp)(nil), "collabTexteditorService.TiTreeNode.Timestamp")
}

func init() { proto.RegisterFile("collabTexteditorService.proto", fileDescriptor_1d586bc6f59f1daa) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CollabTexteditorServiceClient is the client API for CollabTexteditorService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CollabTexteditorServiceClient interface {
	JoinSession(ctx context.Context, in *JoinSessionRequest, opts ...grpc.CallOption) (*JoinSessionResponse, error)
	CreateSessionId(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SessionResponse, error)
	SendLocalUpdate(ctx context.Context, in *LocalUpdateRequest, opts ...grpc.CallOption) (*LocalUpdateReply, error)
	SubscribeForRemoteUpdates(ctx context.Context, in *RemoteUpdateRequest, opts ...grpc.CallOption) (CollabTexteditorService_SubscribeForRemoteUpdatesClient, error)
}

type collabTexteditorServiceClient struct {
	cc *grpc.ClientConn
}

func NewCollabTexteditorServiceClient(cc *grpc.ClientConn) CollabTexteditorServiceClient {
	return &collabTexteditorServiceClient{cc}
}

func (c *collabTexteditorServiceClient) JoinSession(ctx context.Context, in *JoinSessionRequest, opts ...grpc.CallOption) (*JoinSessionResponse, error) {
	out := new(JoinSessionResponse)
	err := c.cc.Invoke(ctx, "/collabTexteditorService.CollabTexteditorService/JoinSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *collabTexteditorServiceClient) CreateSessionId(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SessionResponse, error) {
	out := new(SessionResponse)
	err := c.cc.Invoke(ctx, "/collabTexteditorService.CollabTexteditorService/CreateSessionId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *collabTexteditorServiceClient) SendLocalUpdate(ctx context.Context, in *LocalUpdateRequest, opts ...grpc.CallOption) (*LocalUpdateReply, error) {
	out := new(LocalUpdateReply)
	err := c.cc.Invoke(ctx, "/collabTexteditorService.CollabTexteditorService/SendLocalUpdate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *collabTexteditorServiceClient) SubscribeForRemoteUpdates(ctx context.Context, in *RemoteUpdateRequest, opts ...grpc.CallOption) (CollabTexteditorService_SubscribeForRemoteUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CollabTexteditorService_serviceDesc.Streams[0], "/collabTexteditorService.CollabTexteditorService/SubscribeForRemoteUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &collabTexteditorServiceSubscribeForRemoteUpdatesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CollabTexteditorService_SubscribeForRemoteUpdatesClient interface {
	Recv() (*RemoteUpdateResponse, error)
	grpc.ClientStream
}

type collabTexteditorServiceSubscribeForRemoteUpdatesClient struct {
	grpc.ClientStream
}

func (x *collabTexteditorServiceSubscribeForRemoteUpdatesClient) Recv() (*RemoteUpdateResponse, error) {
	m := new(RemoteUpdateResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// CollabTexteditorServiceServer is the server API for CollabTexteditorService service.
type CollabTexteditorServiceServer interface {
	JoinSession(context.Context, *JoinSessionRequest) (*JoinSessionResponse, error)
	CreateSessionId(context.Context, *Empty) (*SessionResponse, error)
	SendLocalUpdate(context.Context, *LocalUpdateRequest) (*LocalUpdateReply, error)
	SubscribeForRemoteUpdates(*RemoteUpdateRequest, CollabTexteditorService_SubscribeForRemoteUpdatesServer) error
}

// UnimplementedCollabTexteditorServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCollabTexteditorServiceServer struct {
}

func (*UnimplementedCollabTexteditorServiceServer) JoinSession(ctx context.Context, req *JoinSessionRequest) (*JoinSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method JoinSession not implemented")
}
func (*UnimplementedCollabTexteditorServiceServer) CreateSessionId(ctx context.Context, req *Empty) (*SessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSessionId not implemented")
}
func (*UnimplementedCollabTexteditorServiceServer) SendLocalUpdate(ctx context.Context, req *LocalUpdateRequest) (*LocalUpdateReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendLocalUpdate not implemented")
}
func (*UnimplementedCollabTexteditorServiceServer) SubscribeForRemoteUpdates(req *RemoteUpdateRequest, srv CollabTexteditorService_SubscribeForRemoteUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeForRemoteUpdates not implemented")
}

func RegisterCollabTexteditorServiceServer(s *grpc.Server, srv CollabTexteditorServiceServer) {
	s.RegisterService(&_CollabTexteditorService_serviceDesc, srv)
}

func _CollabTexteditorService_JoinSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CollabTexteditorServiceServer).JoinSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/collabTexteditorService.CollabTexteditorService/JoinSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CollabTexteditorServiceServer).JoinSession(ctx, req.(*JoinSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CollabTexteditorService_CreateSessionId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CollabTexteditorServiceServer).CreateSessionId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/collabTexteditorService.CollabTexteditorService/CreateSessionId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CollabTexteditorServiceServer).CreateSessionId(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _CollabTexteditorService_SendLocalUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LocalUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CollabTexteditorServiceServer).SendLocalUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/collabTexteditorService.CollabTexteditorService/SendLocalUpdate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CollabTexteditorServiceServer).SendLocalUpdate(ctx, req.(*LocalUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CollabTexteditorService_SubscribeForRemoteUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RemoteUpdateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CollabTexteditorServiceServer).SubscribeForRemoteUpdates(m, &collabTexteditorServiceSubscribeForRemoteUpdatesServer{stream})
}

type CollabTexteditorService_SubscribeForRemoteUpdatesServer interface {
	Send(*RemoteUpdateResponse) error
	grpc.ServerStream
}

type collabTexteditorServiceSubscribeForRemoteUpdatesServer struct {
	grpc.ServerStream
}

func (x *collabTexteditorServiceSubscribeForRemoteUpdatesServer) Send(m *RemoteUpdateResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _CollabTexteditorService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "collabTexteditorService.CollabTexteditorService",
	HandlerType: (*CollabTexteditorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "JoinSession",
			Handler:    _CollabTexteditorService_JoinSession_Handler,
		},
		{
			MethodName: "CreateSessionId",
			Handler:    _CollabTexteditorService_CreateSessionId_Handler,
		},
		{
			MethodName: "SendLocalUpdate",
			Handler:    _CollabTexteditorService_SendLocalUpdate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SubscribeForRemoteUpdates",
			Handler:       _CollabTexteditorService_SubscribeForRemoteUpdates_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "collabTexteditorService.proto",
}