kind.pb.go

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

package p2p

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import berty_entity "github.com/berty/berty/core/entity"
import _ "github.com/gogo/protobuf/gogoproto"

import io "io"

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

type Kind int32

const (
	Kind_Unknown Kind = 0
	// Sent events are used by the UI.
	Kind_Sent Kind = 101
	// Ack events are created and sent after receiving an event from a peer.
	Kind_Ack Kind = 102
	// Ping events can be use to check and measure the availability of a peer.
	Kind_Ping                   Kind = 103
	Kind_ContactRequest         Kind = 201
	Kind_ContactRequestAccepted Kind = 202
	Kind_ContactShareMe         Kind = 203
	Kind_ContactShare           Kind = 204
)

var Kind_name = map[int32]string{
	0:   "Unknown",
	101: "Sent",
	102: "Ack",
	103: "Ping",
	201: "ContactRequest",
	202: "ContactRequestAccepted",
	203: "ContactShareMe",
	204: "ContactShare",
}
var Kind_value = map[string]int32{
	"Unknown":                0,
	"Sent":                   101,
	"Ack":                    102,
	"Ping":                   103,
	"ContactRequest":         201,
	"ContactRequestAccepted": 202,
	"ContactShareMe":         203,
	"ContactShare":           204,
}

func (x Kind) String() string {
	return proto.EnumName(Kind_name, int32(x))
}
func (Kind) EnumDescriptor() ([]byte, []int) { return fileDescriptorKind, []int{0} }

type SentAttrs struct {
	IDs []string `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"`
}

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

func (m *SentAttrs) GetIDs() []string {
	if m != nil {
		return m.IDs
	}
	return nil
}

type AckAttrs struct {
	IDs []string `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"`
}

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

func (m *AckAttrs) GetIDs() []string {
	if m != nil {
		return m.IDs
	}
	return nil
}

type PingAttrs struct {
}

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

type ContactRequestAttrs struct {
	Me           *berty_entity.Contact `protobuf:"bytes,1,opt,name=me" json:"me,omitempty"`
	IntroMessage string                `protobuf:"bytes,2,opt,name=intro_message,json=introMessage,proto3" json:"intro_message,omitempty"`
}

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

func (m *ContactRequestAttrs) GetMe() *berty_entity.Contact {
	if m != nil {
		return m.Me
	}
	return nil
}

func (m *ContactRequestAttrs) GetIntroMessage() string {
	if m != nil {
		return m.IntroMessage
	}
	return ""
}

type ContactRequestAcceptedAttrs struct {
}

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

type ContactShareMeAttrs struct {
	Me *berty_entity.Contact `protobuf:"bytes,1,opt,name=me" json:"me,omitempty"`
}

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

func (m *ContactShareMeAttrs) GetMe() *berty_entity.Contact {
	if m != nil {
		return m.Me
	}
	return nil
}

type ContactShareAttrs struct {
	Contact *berty_entity.Contact `protobuf:"bytes,1,opt,name=contact" json:"contact,omitempty"`
}

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

func (m *ContactShareAttrs) GetContact() *berty_entity.Contact {
	if m != nil {
		return m.Contact
	}
	return nil
}

func init() {
	proto.RegisterType((*SentAttrs)(nil), "berty.p2p.SentAttrs")
	proto.RegisterType((*AckAttrs)(nil), "berty.p2p.AckAttrs")
	proto.RegisterType((*PingAttrs)(nil), "berty.p2p.PingAttrs")
	proto.RegisterType((*ContactRequestAttrs)(nil), "berty.p2p.ContactRequestAttrs")
	proto.RegisterType((*ContactRequestAcceptedAttrs)(nil), "berty.p2p.ContactRequestAcceptedAttrs")
	proto.RegisterType((*ContactShareMeAttrs)(nil), "berty.p2p.ContactShareMeAttrs")
	proto.RegisterType((*ContactShareAttrs)(nil), "berty.p2p.ContactShareAttrs")
	proto.RegisterEnum("berty.p2p.Kind", Kind_name, Kind_value)
}
func (m *SentAttrs) 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 *SentAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, s := range m.IDs {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *AckAttrs) 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 *AckAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, s := range m.IDs {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *PingAttrs) 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 *PingAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ContactRequestAttrs) 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 *ContactRequestAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Me != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintKind(dAtA, i, uint64(m.Me.Size()))
		n1, err := m.Me.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.IntroMessage) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintKind(dAtA, i, uint64(len(m.IntroMessage)))
		i += copy(dAtA[i:], m.IntroMessage)
	}
	return i, nil
}

func (m *ContactRequestAcceptedAttrs) 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 *ContactRequestAcceptedAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ContactShareMeAttrs) 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 *ContactShareMeAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Me != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintKind(dAtA, i, uint64(m.Me.Size()))
		n2, err := m.Me.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

func (m *ContactShareAttrs) 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 *ContactShareAttrs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Contact != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintKind(dAtA, i, uint64(m.Contact.Size()))
		n3, err := m.Contact.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func encodeVarintKind(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 *SentAttrs) Size() (n int) {
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, s := range m.IDs {
			l = len(s)
			n += 1 + l + sovKind(uint64(l))
		}
	}
	return n
}

func (m *AckAttrs) Size() (n int) {
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, s := range m.IDs {
			l = len(s)
			n += 1 + l + sovKind(uint64(l))
		}
	}
	return n
}

func (m *PingAttrs) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ContactRequestAttrs) Size() (n int) {
	var l int
	_ = l
	if m.Me != nil {
		l = m.Me.Size()
		n += 1 + l + sovKind(uint64(l))
	}
	l = len(m.IntroMessage)
	if l > 0 {
		n += 1 + l + sovKind(uint64(l))
	}
	return n
}

func (m *ContactRequestAcceptedAttrs) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ContactShareMeAttrs) Size() (n int) {
	var l int
	_ = l
	if m.Me != nil {
		l = m.Me.Size()
		n += 1 + l + sovKind(uint64(l))
	}
	return n
}

func (m *ContactShareAttrs) Size() (n int) {
	var l int
	_ = l
	if m.Contact != nil {
		l = m.Contact.Size()
		n += 1 + l + sovKind(uint64(l))
	}
	return n
}

func sovKind(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozKind(x uint64) (n int) {
	return sovKind(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SentAttrs) 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 ErrIntOverflowKind
			}
			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: SentAttrs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SentAttrs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowKind
				}
				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 ErrInvalidLengthKind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IDs = append(m.IDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipKind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthKind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AckAttrs) 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 ErrIntOverflowKind
			}
			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: AckAttrs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AckAttrs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowKind
				}
				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 ErrInvalidLengthKind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IDs = append(m.IDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipKind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthKind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContactRequestAttrs) 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 ErrIntOverflowKind
			}
			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: ContactRequestAttrs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContactRequestAttrs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Me", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowKind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthKind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Me == nil {
				m.Me = &berty_entity.Contact{}
			}
			if err := m.Me.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntroMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowKind
				}
				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 ErrInvalidLengthKind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntroMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipKind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthKind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContactShareAttrs) 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 ErrIntOverflowKind
			}
			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: ContactShareAttrs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContactShareAttrs: 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 ErrIntOverflowKind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthKind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Contact == nil {
				m.Contact = &berty_entity.Contact{}
			}
			if err := m.Contact.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipKind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthKind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipKind(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, ErrIntOverflowKind
			}
			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, ErrIntOverflowKind
				}
				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, ErrIntOverflowKind
				}
				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, ErrInvalidLengthKind
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowKind
					}
					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 := skipKind(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 (
	ErrInvalidLengthKind = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowKind   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("api/p2p/kind.proto", fileDescriptorKind) }

var fileDescriptorKind = []byte{
	// 384 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xdf, 0x8a, 0xda, 0x40,
	0x14, 0xc6, 0x1d, 0x23, 0x8d, 0x39, 0xda, 0x32, 0x8e, 0xb6, 0x58, 0xa5, 0xa9, 0x44, 0x2c, 0xd2,
	0x8b, 0x04, 0x2c, 0xbd, 0xeb, 0x8d, 0xd6, 0x9b, 0x52, 0x84, 0xa2, 0xf4, 0xa6, 0x37, 0x25, 0x4e,
	0xa6, 0x71, 0x08, 0x99, 0x49, 0x93, 0x91, 0xe2, 0x2b, 0xf4, 0x09, 0xfa, 0x48, 0xfd, 0x77, 0xd1,
	0x27, 0x28, 0x4b, 0xf6, 0x45, 0x96, 0x64, 0xe2, 0xe2, 0x2e, 0xcb, 0x2e, 0x7b, 0x33, 0x1c, 0x3e,
	0xbe, 0x33, 0xe7, 0xf7, 0x1d, 0x0e, 0x10, 0x3f, 0xe1, 0x5e, 0x32, 0x4b, 0xbc, 0x88, 0x8b, 0xc0,
	0x4d, 0x52, 0xa9, 0x24, 0xb1, 0xb6, 0x2c, 0x55, 0x07, 0x37, 0x99, 0x25, 0x83, 0x1e, 0x13, 0x8a,
	0xab, 0x83, 0x47, 0xa5, 0x50, 0x3e, 0x55, 0xda, 0x30, 0xe8, 0x85, 0x32, 0x94, 0x65, 0xe9, 0x15,
	0x95, 0x56, 0x9d, 0x17, 0x60, 0x6d, 0x98, 0x50, 0x73, 0xa5, 0xd2, 0x8c, 0x3c, 0x05, 0x83, 0x07,
	0x59, 0x1f, 0x8d, 0x8c, 0xa9, 0xb5, 0x30, 0xf3, 0xff, 0xcf, 0x8d, 0x77, 0xcb, 0x6c, 0x5d, 0x68,
	0xce, 0x04, 0x9a, 0x73, 0x1a, 0xdd, 0x69, 0x6b, 0x81, 0xf5, 0x81, 0x8b, 0xb0, 0xf4, 0x39, 0x3e,
	0x74, 0xdf, 0x6a, 0x84, 0x35, 0xfb, 0xba, 0x67, 0x59, 0x35, 0x65, 0x02, 0xf5, 0x98, 0xf5, 0xd1,
	0x08, 0x4d, 0x5b, 0xb3, 0xc7, 0xae, 0xc6, 0xd6, 0xc4, 0xee, 0xd1, 0x5e, 0x8f, 0x19, 0x19, 0xc3,
	0x43, 0x2e, 0x54, 0x2a, 0x3f, 0xc7, 0x2c, 0xcb, 0xfc, 0x90, 0xf5, 0xeb, 0x23, 0x34, 0xb5, 0xd6,
	0xed, 0x52, 0x5c, 0x69, 0xcd, 0x79, 0x06, 0xc3, 0x6b, 0x23, 0x28, 0x65, 0x89, 0x62, 0x81, 0x26,
	0x78, 0x73, 0x49, 0xb0, 0xd9, 0xf9, 0x29, 0x5b, 0xb1, 0xfb, 0x10, 0x38, 0x4b, 0xe8, 0x9c, 0x76,
	0xeb, 0x5e, 0x0f, 0xcc, 0x6a, 0xaf, 0xb7, 0x7f, 0x70, 0x74, 0xbd, 0xfc, 0x8e, 0xa0, 0xf1, 0x9e,
	0x8b, 0x80, 0xb4, 0xc0, 0xfc, 0x28, 0x22, 0x21, 0xbf, 0x09, 0x5c, 0x23, 0x4d, 0x68, 0x14, 0x7b,
	0xc7, 0x8c, 0x98, 0x60, 0xcc, 0x69, 0x84, 0xbf, 0x14, 0x52, 0xb1, 0x3b, 0x1c, 0x92, 0x2e, 0x3c,
	0xba, 0x9a, 0x0a, 0xff, 0x42, 0x64, 0x08, 0x4f, 0x6e, 0x8e, 0x8a, 0x7f, 0xa3, 0x93, 0x8e, 0x2a,
	0x28, 0xfe, 0x83, 0x48, 0x07, 0xda, 0xa7, 0x22, 0xfe, 0x8b, 0x16, 0xaf, 0x7f, 0xe6, 0x36, 0xfa,
	0x97, 0xdb, 0xe8, 0x2c, 0xb7, 0xd1, 0x8f, 0x73, 0xbb, 0xf6, 0x69, 0x1c, 0x72, 0xb5, 0xdb, 0x6f,
	0x5d, 0x2a, 0x63, 0xaf, 0x0c, 0x52, 0xbd, 0x54, 0xa6, 0xcc, 0xab, 0xee, 0x6c, 0xfb, 0xa0, 0x3c,
	0x96, 0x57, 0x17, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xae, 0x61, 0x32, 0x79, 0x02, 0x00, 0x00,
}