service.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: api/node/service.proto

package node // import "berty.tech/core/api/node"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import p2p "berty.tech/core/api/p2p"
import entity "berty.tech/core/entity"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import io "io"

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

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

type ContactRequestInput struct {
	Contact              *entity.Contact `protobuf:"bytes,1,opt,name=contact" json:"contact,omitempty"`
	IntroText            string          `protobuf:"bytes,2,opt,name=intro_text,json=introText,proto3" json:"intro_text,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_ContactRequestInput proto.InternalMessageInfo

func (m *ContactRequestInput) GetContact() *entity.Contact {
	if m != nil {
		return m.Contact
	}
	return nil
}

func (m *ContactRequestInput) GetIntroText() string {
	if m != nil {
		return m.IntroText
	}
	return ""
}

type ConversationAddMessageInput struct {
	Conversation         *entity.Conversation `protobuf:"bytes,1,opt,name=conversation" json:"conversation,omitempty"`
	Message              *entity.Message      `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_ConversationAddMessageInput proto.InternalMessageInfo

func (m *ConversationAddMessageInput) GetConversation() *entity.Conversation {
	if m != nil {
		return m.Conversation
	}
	return nil
}

func (m *ConversationAddMessageInput) GetMessage() *entity.Message {
	if m != nil {
		return m.Message
	}
	return nil
}

type EventListInput struct {
	Limit                uint32     `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	Filter               *p2p.Event `protobuf:"bytes,2,opt,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_EventListInput proto.InternalMessageInfo

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

func (m *EventListInput) GetFilter() *p2p.Event {
	if m != nil {
		return m.Filter
	}
	return nil
}

type ConversationManageMembersInput struct {
	Conversation         *entity.Conversation         `protobuf:"bytes,1,opt,name=conversation" json:"conversation,omitempty"`
	Members              []*entity.ConversationMember `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_ConversationManageMembersInput proto.InternalMessageInfo

func (m *ConversationManageMembersInput) GetConversation() *entity.Conversation {
	if m != nil {
		return m.Conversation
	}
	return nil
}

func (m *ConversationManageMembersInput) GetMembers() []*entity.ConversationMember {
	if m != nil {
		return m.Members
	}
	return nil
}

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

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

var xxx_messageInfo_Void proto.InternalMessageInfo

var E_GraphqlFields = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.MethodOptions)(nil),
	ExtensionType: (*string)(nil),
	Field:         53001,
	Name:          "berty.node.graphql_fields",
	Tag:           "bytes,53001,opt,name=graphql_fields,json=graphqlFields",
	Filename:      "api/node/service.proto",
}

var E_GraphqlId = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.MethodOptions)(nil),
	ExtensionType: (*string)(nil),
	Field:         53002,
	Name:          "berty.node.graphql_id",
	Tag:           "bytes,53002,opt,name=graphql_id,json=graphqlId",
	Filename:      "api/node/service.proto",
}

var E_GraphqlType = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.MethodOptions)(nil),
	ExtensionType: (*string)(nil),
	Field:         53003,
	Name:          "berty.node.graphql_type",
	Tag:           "bytes,53003,opt,name=graphql_type,json=graphqlType",
	Filename:      "api/node/service.proto",
}

func init() {
	proto.RegisterType((*ContactRequestInput)(nil), "berty.node.ContactRequestInput")
	proto.RegisterType((*ConversationAddMessageInput)(nil), "berty.node.ConversationAddMessageInput")
	proto.RegisterType((*EventListInput)(nil), "berty.node.EventListInput")
	proto.RegisterType((*ConversationManageMembersInput)(nil), "berty.node.ConversationManageMembersInput")
	proto.RegisterType((*Void)(nil), "berty.node.Void")
	proto.RegisterExtension(E_GraphqlFields)
	proto.RegisterExtension(E_GraphqlId)
	proto.RegisterExtension(E_GraphqlType)
}

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

// ServiceClient is the client API for Service service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ServiceClient interface {
	// yield new events in real-time
	EventStream(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_EventStreamClient, error)
	// list old events
	EventList(ctx context.Context, in *EventListInput, opts ...grpc.CallOption) (Service_EventListClient, error)
	ContactRequest(ctx context.Context, in *ContactRequestInput, opts ...grpc.CallOption) (*entity.Contact, error)
	ContactAcceptRequest(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error)
	ContactRemove(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error)
	ContactUpdate(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error)
	ContactList(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_ContactListClient, error)
	ConversationCreate(ctx context.Context, in *entity.Conversation, opts ...grpc.CallOption) (*entity.Conversation, error)
	ConversationList(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_ConversationListClient, error)
	ConversationInvite(ctx context.Context, in *ConversationManageMembersInput, opts ...grpc.CallOption) (*entity.Conversation, error)
	ConversationExclude(ctx context.Context, in *ConversationManageMembersInput, opts ...grpc.CallOption) (*entity.Conversation, error)
	ConversationAddMessage(ctx context.Context, in *ConversationAddMessageInput, opts ...grpc.CallOption) (*p2p.Event, error)
	// HandleEvent is the unencrypted (and unsafe) version of HandleEnvelope.
	// it's only exposed over the node API, it should be completely deactivated in public releases
	HandleEvent(ctx context.Context, in *p2p.Event, opts ...grpc.CallOption) (*Void, error)
	GenerateFakeData(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Void, error)
}

type serviceClient struct {
	cc *grpc.ClientConn
}

func NewServiceClient(cc *grpc.ClientConn) ServiceClient {
	return &serviceClient{cc}
}

func (c *serviceClient) EventStream(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_EventStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[0], "/berty.node.Service/EventStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceEventStreamClient{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 Service_EventStreamClient interface {
	Recv() (*p2p.Event, error)
	grpc.ClientStream
}

type serviceEventStreamClient struct {
	grpc.ClientStream
}

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

func (c *serviceClient) EventList(ctx context.Context, in *EventListInput, opts ...grpc.CallOption) (Service_EventListClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[1], "/berty.node.Service/EventList", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceEventListClient{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 Service_EventListClient interface {
	Recv() (*p2p.Event, error)
	grpc.ClientStream
}

type serviceEventListClient struct {
	grpc.ClientStream
}

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

func (c *serviceClient) ContactRequest(ctx context.Context, in *ContactRequestInput, opts ...grpc.CallOption) (*entity.Contact, error) {
	out := new(entity.Contact)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ContactRequest", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ContactAcceptRequest(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error) {
	out := new(entity.Contact)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ContactAcceptRequest", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ContactRemove(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error) {
	out := new(entity.Contact)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ContactRemove", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ContactUpdate(ctx context.Context, in *entity.Contact, opts ...grpc.CallOption) (*entity.Contact, error) {
	out := new(entity.Contact)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ContactUpdate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ContactList(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_ContactListClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[2], "/berty.node.Service/ContactList", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceContactListClient{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 Service_ContactListClient interface {
	Recv() (*entity.Contact, error)
	grpc.ClientStream
}

type serviceContactListClient struct {
	grpc.ClientStream
}

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

func (c *serviceClient) ConversationCreate(ctx context.Context, in *entity.Conversation, opts ...grpc.CallOption) (*entity.Conversation, error) {
	out := new(entity.Conversation)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ConversationCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ConversationList(ctx context.Context, in *Void, opts ...grpc.CallOption) (Service_ConversationListClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[3], "/berty.node.Service/ConversationList", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceConversationListClient{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 Service_ConversationListClient interface {
	Recv() (*entity.Conversation, error)
	grpc.ClientStream
}

type serviceConversationListClient struct {
	grpc.ClientStream
}

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

func (c *serviceClient) ConversationInvite(ctx context.Context, in *ConversationManageMembersInput, opts ...grpc.CallOption) (*entity.Conversation, error) {
	out := new(entity.Conversation)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ConversationInvite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ConversationExclude(ctx context.Context, in *ConversationManageMembersInput, opts ...grpc.CallOption) (*entity.Conversation, error) {
	out := new(entity.Conversation)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ConversationExclude", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ConversationAddMessage(ctx context.Context, in *ConversationAddMessageInput, opts ...grpc.CallOption) (*p2p.Event, error) {
	out := new(p2p.Event)
	err := c.cc.Invoke(ctx, "/berty.node.Service/ConversationAddMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) HandleEvent(ctx context.Context, in *p2p.Event, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := c.cc.Invoke(ctx, "/berty.node.Service/HandleEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) GenerateFakeData(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := c.cc.Invoke(ctx, "/berty.node.Service/GenerateFakeData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServiceServer is the server API for Service service.
type ServiceServer interface {
	// yield new events in real-time
	EventStream(*Void, Service_EventStreamServer) error
	// list old events
	EventList(*EventListInput, Service_EventListServer) error
	ContactRequest(context.Context, *ContactRequestInput) (*entity.Contact, error)
	ContactAcceptRequest(context.Context, *entity.Contact) (*entity.Contact, error)
	ContactRemove(context.Context, *entity.Contact) (*entity.Contact, error)
	ContactUpdate(context.Context, *entity.Contact) (*entity.Contact, error)
	ContactList(*Void, Service_ContactListServer) error
	ConversationCreate(context.Context, *entity.Conversation) (*entity.Conversation, error)
	ConversationList(*Void, Service_ConversationListServer) error
	ConversationInvite(context.Context, *ConversationManageMembersInput) (*entity.Conversation, error)
	ConversationExclude(context.Context, *ConversationManageMembersInput) (*entity.Conversation, error)
	ConversationAddMessage(context.Context, *ConversationAddMessageInput) (*p2p.Event, error)
	// HandleEvent is the unencrypted (and unsafe) version of HandleEnvelope.
	// it's only exposed over the node API, it should be completely deactivated in public releases
	HandleEvent(context.Context, *p2p.Event) (*Void, error)
	GenerateFakeData(context.Context, *Void) (*Void, error)
}

func RegisterServiceServer(s *grpc.Server, srv ServiceServer) {
	s.RegisterService(&_Service_serviceDesc, srv)
}

func _Service_EventStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Void)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).EventStream(m, &serviceEventStreamServer{stream})
}

type Service_EventStreamServer interface {
	Send(*p2p.Event) error
	grpc.ServerStream
}

type serviceEventStreamServer struct {
	grpc.ServerStream
}

func (x *serviceEventStreamServer) Send(m *p2p.Event) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_EventList_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(EventListInput)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).EventList(m, &serviceEventListServer{stream})
}

type Service_EventListServer interface {
	Send(*p2p.Event) error
	grpc.ServerStream
}

type serviceEventListServer struct {
	grpc.ServerStream
}

func (x *serviceEventListServer) Send(m *p2p.Event) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_ContactRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContactRequestInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ContactRequest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ContactRequest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ContactRequest(ctx, req.(*ContactRequestInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ContactAcceptRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(entity.Contact)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ContactAcceptRequest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ContactAcceptRequest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ContactAcceptRequest(ctx, req.(*entity.Contact))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ContactRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(entity.Contact)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ContactRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ContactRemove",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ContactRemove(ctx, req.(*entity.Contact))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ContactUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(entity.Contact)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ContactUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ContactUpdate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ContactUpdate(ctx, req.(*entity.Contact))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ContactList_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Void)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).ContactList(m, &serviceContactListServer{stream})
}

type Service_ContactListServer interface {
	Send(*entity.Contact) error
	grpc.ServerStream
}

type serviceContactListServer struct {
	grpc.ServerStream
}

func (x *serviceContactListServer) Send(m *entity.Contact) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_ConversationCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(entity.Conversation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ConversationCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ConversationCreate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ConversationCreate(ctx, req.(*entity.Conversation))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ConversationList_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Void)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).ConversationList(m, &serviceConversationListServer{stream})
}

type Service_ConversationListServer interface {
	Send(*entity.Conversation) error
	grpc.ServerStream
}

type serviceConversationListServer struct {
	grpc.ServerStream
}

func (x *serviceConversationListServer) Send(m *entity.Conversation) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_ConversationInvite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConversationManageMembersInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ConversationInvite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ConversationInvite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ConversationInvite(ctx, req.(*ConversationManageMembersInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ConversationExclude_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConversationManageMembersInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ConversationExclude(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ConversationExclude",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ConversationExclude(ctx, req.(*ConversationManageMembersInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ConversationAddMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConversationAddMessageInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ConversationAddMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/ConversationAddMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ConversationAddMessage(ctx, req.(*ConversationAddMessageInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_HandleEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(p2p.Event)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).HandleEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/HandleEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).HandleEvent(ctx, req.(*p2p.Event))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_GenerateFakeData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).GenerateFakeData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.node.Service/GenerateFakeData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).GenerateFakeData(ctx, req.(*Void))
	}
	return interceptor(ctx, in, info, handler)
}

var _Service_serviceDesc = grpc.ServiceDesc{
	ServiceName: "berty.node.Service",
	HandlerType: (*ServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ContactRequest",
			Handler:    _Service_ContactRequest_Handler,
		},
		{
			MethodName: "ContactAcceptRequest",
			Handler:    _Service_ContactAcceptRequest_Handler,
		},
		{
			MethodName: "ContactRemove",
			Handler:    _Service_ContactRemove_Handler,
		},
		{
			MethodName: "ContactUpdate",
			Handler:    _Service_ContactUpdate_Handler,
		},
		{
			MethodName: "ConversationCreate",
			Handler:    _Service_ConversationCreate_Handler,
		},
		{
			MethodName: "ConversationInvite",
			Handler:    _Service_ConversationInvite_Handler,
		},
		{
			MethodName: "ConversationExclude",
			Handler:    _Service_ConversationExclude_Handler,
		},
		{
			MethodName: "ConversationAddMessage",
			Handler:    _Service_ConversationAddMessage_Handler,
		},
		{
			MethodName: "HandleEvent",
			Handler:    _Service_HandleEvent_Handler,
		},
		{
			MethodName: "GenerateFakeData",
			Handler:    _Service_GenerateFakeData_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "EventStream",
			Handler:       _Service_EventStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "EventList",
			Handler:       _Service_EventList_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ContactList",
			Handler:       _Service_ContactList_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ConversationList",
			Handler:       _Service_ConversationList_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/node/service.proto",
}

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

func (m *ContactRequestInput) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Contact != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Contact.Size()))
		n1, err := m.Contact.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.IntroText) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.IntroText)))
		i += copy(dAtA[i:], m.IntroText)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ConversationAddMessageInput) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Conversation != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Conversation.Size()))
		n2, err := m.Conversation.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Message != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Message.Size()))
		n3, err := m.Message.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *EventListInput) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Limit != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Limit))
	}
	if m.Filter != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Filter.Size()))
		n4, err := m.Filter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ConversationManageMembersInput) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Conversation != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Conversation.Size()))
		n5, err := m.Conversation.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if len(m.Members) > 0 {
		for _, msg := range m.Members {
			dAtA[i] = 0x12
			i++
			i = encodeVarintService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Void) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *ContactRequestInput) Size() (n int) {
	var l int
	_ = l
	if m.Contact != nil {
		l = m.Contact.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.IntroText)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ConversationAddMessageInput) Size() (n int) {
	var l int
	_ = l
	if m.Conversation != nil {
		l = m.Conversation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EventListInput) Size() (n int) {
	var l int
	_ = l
	if m.Limit != 0 {
		n += 1 + sovService(uint64(m.Limit))
	}
	if m.Filter != nil {
		l = m.Filter.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ConversationManageMembersInput) Size() (n int) {
	var l int
	_ = l
	if m.Conversation != nil {
		l = m.Conversation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Members) > 0 {
		for _, e := range m.Members {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Void) Size() (n int) {
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovService(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ContactRequestInput) 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 ErrIntOverflowService
			}
			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: ContactRequestInput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContactRequestInput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contact", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Contact == nil {
				m.Contact = &entity.Contact{}
			}
			if err := m.Contact.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntroText", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntroText = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConversationAddMessageInput) 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 ErrIntOverflowService
			}
			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: ConversationAddMessageInput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConversationAddMessageInput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conversation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Conversation == nil {
				m.Conversation = &entity.Conversation{}
			}
			if err := m.Conversation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &entity.Message{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventListInput) 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 ErrIntOverflowService
			}
			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: EventListInput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventListInput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Filter == nil {
				m.Filter = &p2p.Event{}
			}
			if err := m.Filter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConversationManageMembersInput) 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 ErrIntOverflowService
			}
			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: ConversationManageMembersInput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConversationManageMembersInput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conversation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Conversation == nil {
				m.Conversation = &entity.Conversation{}
			}
			if err := m.Conversation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Members = append(m.Members, &entity.ConversationMember{})
			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Void) 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 ErrIntOverflowService
			}
			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: Void: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Void: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipService(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowService
			}
			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, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthService
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowService
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipService(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthService = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("api/node/service.proto", fileDescriptor_service_16a01b6c717a7ccc) }

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