bertyreplication.pb.go

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

package replicationtypes

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"

	protocoltypes "berty.tech/berty/v2/go/pkg/protocoltypes"
)

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

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

type ReplicatedGroup struct {
	PublicKey            string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" gorm:"primaryKey"`
	SignPub              string `protobuf:"bytes,2,opt,name=sign_pub,json=signPub,proto3" json:"sign_pub,omitempty"`
	LinkKey              string `protobuf:"bytes,3,opt,name=link_key,json=linkKey,proto3" json:"link_key,omitempty"`
	CreatedAt            int64  `protobuf:"varint,100,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt            int64  `protobuf:"varint,101,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	MetadataEntriesCount int64  `protobuf:"varint,102,opt,name=metadata_entries_count,json=metadataEntriesCount,proto3" json:"metadata_entries_count,omitempty"`
	MetadataLatestHead   string `protobuf:"bytes,103,opt,name=metadata_latest_head,json=metadataLatestHead,proto3" json:"metadata_latest_head,omitempty"`
	MessageEntriesCount  int64  `protobuf:"varint,104,opt,name=message_entries_count,json=messageEntriesCount,proto3" json:"message_entries_count,omitempty"`
	MessageLatestHead    string `protobuf:"bytes,105,opt,name=message_latest_head,json=messageLatestHead,proto3" json:"message_latest_head,omitempty"`
}

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

func (m *ReplicatedGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicatedGroup.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicatedGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicatedGroup.Merge(m, src)
}

func (m *ReplicatedGroup) XXX_Size() int {
	return m.Size()
}

func (m *ReplicatedGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicatedGroup.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicatedGroup proto.InternalMessageInfo

func (m *ReplicatedGroup) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func (m *ReplicatedGroup) GetSignPub() string {
	if m != nil {
		return m.SignPub
	}
	return ""
}

func (m *ReplicatedGroup) GetLinkKey() string {
	if m != nil {
		return m.LinkKey
	}
	return ""
}

func (m *ReplicatedGroup) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *ReplicatedGroup) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *ReplicatedGroup) GetMetadataEntriesCount() int64 {
	if m != nil {
		return m.MetadataEntriesCount
	}
	return 0
}

func (m *ReplicatedGroup) GetMetadataLatestHead() string {
	if m != nil {
		return m.MetadataLatestHead
	}
	return ""
}

func (m *ReplicatedGroup) GetMessageEntriesCount() int64 {
	if m != nil {
		return m.MessageEntriesCount
	}
	return 0
}

func (m *ReplicatedGroup) GetMessageLatestHead() string {
	if m != nil {
		return m.MessageLatestHead
	}
	return ""
}

type ReplicatedGroupToken struct {
	ReplicatedGroupPublicKey string           `protobuf:"bytes,1,opt,name=replicated_group_public_key,json=replicatedGroupPublicKey,proto3" json:"replicated_group_public_key,omitempty" gorm:"index;primaryKey;autoIncrement:false"`
	ReplicatedGroup          *ReplicatedGroup `protobuf:"bytes,2,opt,name=replicated_group,json=replicatedGroup,proto3" json:"replicated_group,omitempty"`
	TokenIssuer              string           `protobuf:"bytes,3,opt,name=token_issuer,json=tokenIssuer,proto3" json:"token_issuer,omitempty" gorm:"primaryKey;autoIncrement:false"`
	TokenID                  string           `protobuf:"bytes,4,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty" gorm:"primaryKey;autoIncrement:false"`
	CreatedAt                int64            `protobuf:"varint,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
}

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

func (m *ReplicatedGroupToken) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicatedGroupToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicatedGroupToken.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicatedGroupToken) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicatedGroupToken.Merge(m, src)
}

func (m *ReplicatedGroupToken) XXX_Size() int {
	return m.Size()
}

func (m *ReplicatedGroupToken) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicatedGroupToken.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicatedGroupToken proto.InternalMessageInfo

func (m *ReplicatedGroupToken) GetReplicatedGroupPublicKey() string {
	if m != nil {
		return m.ReplicatedGroupPublicKey
	}
	return ""
}

func (m *ReplicatedGroupToken) GetReplicatedGroup() *ReplicatedGroup {
	if m != nil {
		return m.ReplicatedGroup
	}
	return nil
}

func (m *ReplicatedGroupToken) GetTokenIssuer() string {
	if m != nil {
		return m.TokenIssuer
	}
	return ""
}

func (m *ReplicatedGroupToken) GetTokenID() string {
	if m != nil {
		return m.TokenID
	}
	return ""
}

func (m *ReplicatedGroupToken) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

type ReplicationServiceReplicateGroup struct{}

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

func (m *ReplicationServiceReplicateGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicationServiceReplicateGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicationServiceReplicateGroup.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicationServiceReplicateGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationServiceReplicateGroup.Merge(m, src)
}

func (m *ReplicationServiceReplicateGroup) XXX_Size() int {
	return m.Size()
}

func (m *ReplicationServiceReplicateGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationServiceReplicateGroup.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationServiceReplicateGroup proto.InternalMessageInfo

type ReplicationServiceReplicateGroup_Request struct {
	Group *protocoltypes.Group `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"`
}

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

func (m *ReplicationServiceReplicateGroup_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicationServiceReplicateGroup_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicationServiceReplicateGroup_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicationServiceReplicateGroup_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationServiceReplicateGroup_Request.Merge(m, src)
}

func (m *ReplicationServiceReplicateGroup_Request) XXX_Size() int {
	return m.Size()
}

func (m *ReplicationServiceReplicateGroup_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationServiceReplicateGroup_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationServiceReplicateGroup_Request proto.InternalMessageInfo

func (m *ReplicationServiceReplicateGroup_Request) GetGroup() *protocoltypes.Group {
	if m != nil {
		return m.Group
	}
	return nil
}

type ReplicationServiceReplicateGroup_Reply struct {
	OK bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
}

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

func (m *ReplicationServiceReplicateGroup_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicationServiceReplicateGroup_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicationServiceReplicateGroup_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicationServiceReplicateGroup_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationServiceReplicateGroup_Reply.Merge(m, src)
}

func (m *ReplicationServiceReplicateGroup_Reply) XXX_Size() int {
	return m.Size()
}

func (m *ReplicationServiceReplicateGroup_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationServiceReplicateGroup_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationServiceReplicateGroup_Reply proto.InternalMessageInfo

func (m *ReplicationServiceReplicateGroup_Reply) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

type ReplicateGlobalStats struct{}

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

func (m *ReplicateGlobalStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGlobalStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGlobalStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGlobalStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGlobalStats.Merge(m, src)
}

func (m *ReplicateGlobalStats) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGlobalStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGlobalStats.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGlobalStats proto.InternalMessageInfo

type ReplicateGlobalStats_Request struct{}

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

func (m *ReplicateGlobalStats_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGlobalStats_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGlobalStats_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGlobalStats_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGlobalStats_Request.Merge(m, src)
}

func (m *ReplicateGlobalStats_Request) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGlobalStats_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGlobalStats_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGlobalStats_Request proto.InternalMessageInfo

type ReplicateGlobalStats_Reply struct {
	StartedAt            int64 `protobuf:"varint,1,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
	ReplicatedGroups     int64 `protobuf:"varint,2,opt,name=replicated_groups,json=replicatedGroups,proto3" json:"replicated_groups,omitempty"`
	TotalMetadataEntries int64 `protobuf:"varint,3,opt,name=total_metadata_entries,json=totalMetadataEntries,proto3" json:"total_metadata_entries,omitempty"`
	TotalMessageEntries  int64 `protobuf:"varint,4,opt,name=total_message_entries,json=totalMessageEntries,proto3" json:"total_message_entries,omitempty"`
}

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

func (m *ReplicateGlobalStats_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGlobalStats_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGlobalStats_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGlobalStats_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGlobalStats_Reply.Merge(m, src)
}

func (m *ReplicateGlobalStats_Reply) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGlobalStats_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGlobalStats_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGlobalStats_Reply proto.InternalMessageInfo

func (m *ReplicateGlobalStats_Reply) GetStartedAt() int64 {
	if m != nil {
		return m.StartedAt
	}
	return 0
}

func (m *ReplicateGlobalStats_Reply) GetReplicatedGroups() int64 {
	if m != nil {
		return m.ReplicatedGroups
	}
	return 0
}

func (m *ReplicateGlobalStats_Reply) GetTotalMetadataEntries() int64 {
	if m != nil {
		return m.TotalMetadataEntries
	}
	return 0
}

func (m *ReplicateGlobalStats_Reply) GetTotalMessageEntries() int64 {
	if m != nil {
		return m.TotalMessageEntries
	}
	return 0
}

type ReplicateGroupStats struct{}

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

func (m *ReplicateGroupStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGroupStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGroupStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGroupStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGroupStats.Merge(m, src)
}

func (m *ReplicateGroupStats) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGroupStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGroupStats.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGroupStats proto.InternalMessageInfo

type ReplicateGroupStats_Request struct {
	GroupPublicKey string `protobuf:"bytes,1,opt,name=group_public_key,json=groupPublicKey,proto3" json:"group_public_key,omitempty"`
}

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

func (m *ReplicateGroupStats_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGroupStats_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGroupStats_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGroupStats_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGroupStats_Request.Merge(m, src)
}

func (m *ReplicateGroupStats_Request) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGroupStats_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGroupStats_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGroupStats_Request proto.InternalMessageInfo

func (m *ReplicateGroupStats_Request) GetGroupPublicKey() string {
	if m != nil {
		return m.GroupPublicKey
	}
	return ""
}

type ReplicateGroupStats_Reply struct {
	Group *ReplicatedGroup `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"`
}

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

func (m *ReplicateGroupStats_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ReplicateGroupStats_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicateGroupStats_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ReplicateGroupStats_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicateGroupStats_Reply.Merge(m, src)
}

func (m *ReplicateGroupStats_Reply) XXX_Size() int {
	return m.Size()
}

func (m *ReplicateGroupStats_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicateGroupStats_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicateGroupStats_Reply proto.InternalMessageInfo

func (m *ReplicateGroupStats_Reply) GetGroup() *ReplicatedGroup {
	if m != nil {
		return m.Group
	}
	return nil
}

func init() {
	proto.RegisterType((*ReplicatedGroup)(nil), "berty.replication.v1.ReplicatedGroup")
	proto.RegisterType((*ReplicatedGroupToken)(nil), "berty.replication.v1.ReplicatedGroupToken")
	proto.RegisterType((*ReplicationServiceReplicateGroup)(nil), "berty.replication.v1.ReplicationServiceReplicateGroup")
	proto.RegisterType((*ReplicationServiceReplicateGroup_Request)(nil), "berty.replication.v1.ReplicationServiceReplicateGroup.Request")
	proto.RegisterType((*ReplicationServiceReplicateGroup_Reply)(nil), "berty.replication.v1.ReplicationServiceReplicateGroup.Reply")
	proto.RegisterType((*ReplicateGlobalStats)(nil), "berty.replication.v1.ReplicateGlobalStats")
	proto.RegisterType((*ReplicateGlobalStats_Request)(nil), "berty.replication.v1.ReplicateGlobalStats.Request")
	proto.RegisterType((*ReplicateGlobalStats_Reply)(nil), "berty.replication.v1.ReplicateGlobalStats.Reply")
	proto.RegisterType((*ReplicateGroupStats)(nil), "berty.replication.v1.ReplicateGroupStats")
	proto.RegisterType((*ReplicateGroupStats_Request)(nil), "berty.replication.v1.ReplicateGroupStats.Request")
	proto.RegisterType((*ReplicateGroupStats_Reply)(nil), "berty.replication.v1.ReplicateGroupStats.Reply")
}

func init() { proto.RegisterFile("bertyreplication.proto", fileDescriptor_07ad8506da4f8389) }

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ 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

// ReplicationServiceClient is the client API for ReplicationService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReplicationServiceClient interface {
	// ReplicateGroup
	ReplicateGroup(ctx context.Context, in *ReplicationServiceReplicateGroup_Request, opts ...grpc.CallOption) (*ReplicationServiceReplicateGroup_Reply, error)
	ReplicateGlobalStats(ctx context.Context, in *ReplicateGlobalStats_Request, opts ...grpc.CallOption) (*ReplicateGlobalStats_Reply, error)
	ReplicateGroupStats(ctx context.Context, in *ReplicateGroupStats_Request, opts ...grpc.CallOption) (*ReplicateGroupStats_Reply, error)
}

type replicationServiceClient struct {
	cc *grpc.ClientConn
}

func NewReplicationServiceClient(cc *grpc.ClientConn) ReplicationServiceClient {
	return &replicationServiceClient{cc}
}

func (c *replicationServiceClient) ReplicateGroup(ctx context.Context, in *ReplicationServiceReplicateGroup_Request, opts ...grpc.CallOption) (*ReplicationServiceReplicateGroup_Reply, error) {
	out := new(ReplicationServiceReplicateGroup_Reply)
	err := c.cc.Invoke(ctx, "/berty.replication.v1.ReplicationService/ReplicateGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationServiceClient) ReplicateGlobalStats(ctx context.Context, in *ReplicateGlobalStats_Request, opts ...grpc.CallOption) (*ReplicateGlobalStats_Reply, error) {
	out := new(ReplicateGlobalStats_Reply)
	err := c.cc.Invoke(ctx, "/berty.replication.v1.ReplicationService/ReplicateGlobalStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationServiceClient) ReplicateGroupStats(ctx context.Context, in *ReplicateGroupStats_Request, opts ...grpc.CallOption) (*ReplicateGroupStats_Reply, error) {
	out := new(ReplicateGroupStats_Reply)
	err := c.cc.Invoke(ctx, "/berty.replication.v1.ReplicationService/ReplicateGroupStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplicationServiceServer is the server API for ReplicationService service.
type ReplicationServiceServer interface {
	// ReplicateGroup
	ReplicateGroup(context.Context, *ReplicationServiceReplicateGroup_Request) (*ReplicationServiceReplicateGroup_Reply, error)
	ReplicateGlobalStats(context.Context, *ReplicateGlobalStats_Request) (*ReplicateGlobalStats_Reply, error)
	ReplicateGroupStats(context.Context, *ReplicateGroupStats_Request) (*ReplicateGroupStats_Reply, error)
}

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

func (*UnimplementedReplicationServiceServer) ReplicateGroup(ctx context.Context, req *ReplicationServiceReplicateGroup_Request) (*ReplicationServiceReplicateGroup_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicateGroup not implemented")
}

func (*UnimplementedReplicationServiceServer) ReplicateGlobalStats(ctx context.Context, req *ReplicateGlobalStats_Request) (*ReplicateGlobalStats_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicateGlobalStats not implemented")
}

func (*UnimplementedReplicationServiceServer) ReplicateGroupStats(ctx context.Context, req *ReplicateGroupStats_Request) (*ReplicateGroupStats_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicateGroupStats not implemented")
}

func RegisterReplicationServiceServer(s *grpc.Server, srv ReplicationServiceServer) {
	s.RegisterService(&_ReplicationService_serviceDesc, srv)
}

func _ReplicationService_ReplicateGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicationServiceReplicateGroup_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServiceServer).ReplicateGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.replication.v1.ReplicationService/ReplicateGroup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServiceServer).ReplicateGroup(ctx, req.(*ReplicationServiceReplicateGroup_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicationService_ReplicateGlobalStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicateGlobalStats_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServiceServer).ReplicateGlobalStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.replication.v1.ReplicationService/ReplicateGlobalStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServiceServer).ReplicateGlobalStats(ctx, req.(*ReplicateGlobalStats_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicationService_ReplicateGroupStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicateGroupStats_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServiceServer).ReplicateGroupStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.replication.v1.ReplicationService/ReplicateGroupStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServiceServer).ReplicateGroupStats(ctx, req.(*ReplicateGroupStats_Request))
	}
	return interceptor(ctx, in, info, handler)
}

var _ReplicationService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "berty.replication.v1.ReplicationService",
	HandlerType: (*ReplicationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReplicateGroup",
			Handler:    _ReplicationService_ReplicateGroup_Handler,
		},
		{
			MethodName: "ReplicateGlobalStats",
			Handler:    _ReplicationService_ReplicateGlobalStats_Handler,
		},
		{
			MethodName: "ReplicateGroupStats",
			Handler:    _ReplicationService_ReplicateGroupStats_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "bertyreplication.proto",
}

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

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

func (m *ReplicatedGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MessageLatestHead) > 0 {
		i -= len(m.MessageLatestHead)
		copy(dAtA[i:], m.MessageLatestHead)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.MessageLatestHead)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xca
	}
	if m.MessageEntriesCount != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.MessageEntriesCount))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xc0
	}
	if len(m.MetadataLatestHead) > 0 {
		i -= len(m.MetadataLatestHead)
		copy(dAtA[i:], m.MetadataLatestHead)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.MetadataLatestHead)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xba
	}
	if m.MetadataEntriesCount != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.MetadataEntriesCount))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xb0
	}
	if m.UpdatedAt != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa8
	}
	if m.CreatedAt != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa0
	}
	if len(m.LinkKey) > 0 {
		i -= len(m.LinkKey)
		copy(dAtA[i:], m.LinkKey)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.LinkKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SignPub) > 0 {
		i -= len(m.SignPub)
		copy(dAtA[i:], m.SignPub)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.SignPub)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ReplicatedGroupToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CreatedAt != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x28
	}
	if len(m.TokenID) > 0 {
		i -= len(m.TokenID)
		copy(dAtA[i:], m.TokenID)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.TokenID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TokenIssuer) > 0 {
		i -= len(m.TokenIssuer)
		copy(dAtA[i:], m.TokenIssuer)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.TokenIssuer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ReplicatedGroup != nil {
		{
			size, err := m.ReplicatedGroup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBertyreplication(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ReplicatedGroupPublicKey) > 0 {
		i -= len(m.ReplicatedGroupPublicKey)
		copy(dAtA[i:], m.ReplicatedGroupPublicKey)
		i = encodeVarintBertyreplication(dAtA, i, uint64(len(m.ReplicatedGroupPublicKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ReplicateGlobalStats_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalMessageEntries != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.TotalMessageEntries))
		i--
		dAtA[i] = 0x20
	}
	if m.TotalMetadataEntries != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.TotalMetadataEntries))
		i--
		dAtA[i] = 0x18
	}
	if m.ReplicatedGroups != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.ReplicatedGroups))
		i--
		dAtA[i] = 0x10
	}
	if m.StartedAt != 0 {
		i = encodeVarintBertyreplication(dAtA, i, uint64(m.StartedAt))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func encodeVarintBertyreplication(dAtA []byte, offset int, v uint64) int {
	offset -= sovBertyreplication(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *ReplicatedGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	l = len(m.SignPub)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	l = len(m.LinkKey)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 2 + sovBertyreplication(uint64(m.CreatedAt))
	}
	if m.UpdatedAt != 0 {
		n += 2 + sovBertyreplication(uint64(m.UpdatedAt))
	}
	if m.MetadataEntriesCount != 0 {
		n += 2 + sovBertyreplication(uint64(m.MetadataEntriesCount))
	}
	l = len(m.MetadataLatestHead)
	if l > 0 {
		n += 2 + l + sovBertyreplication(uint64(l))
	}
	if m.MessageEntriesCount != 0 {
		n += 2 + sovBertyreplication(uint64(m.MessageEntriesCount))
	}
	l = len(m.MessageLatestHead)
	if l > 0 {
		n += 2 + l + sovBertyreplication(uint64(l))
	}
	return n
}

func (m *ReplicatedGroupToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ReplicatedGroupPublicKey)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	if m.ReplicatedGroup != nil {
		l = m.ReplicatedGroup.Size()
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	l = len(m.TokenIssuer)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	l = len(m.TokenID)
	if l > 0 {
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovBertyreplication(uint64(m.CreatedAt))
	}
	return n
}

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

func (m *ReplicationServiceReplicateGroup_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Group != nil {
		l = m.Group.Size()
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	return n
}

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

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

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

func (m *ReplicateGlobalStats_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartedAt != 0 {
		n += 1 + sovBertyreplication(uint64(m.StartedAt))
	}
	if m.ReplicatedGroups != 0 {
		n += 1 + sovBertyreplication(uint64(m.ReplicatedGroups))
	}
	if m.TotalMetadataEntries != 0 {
		n += 1 + sovBertyreplication(uint64(m.TotalMetadataEntries))
	}
	if m.TotalMessageEntries != 0 {
		n += 1 + sovBertyreplication(uint64(m.TotalMessageEntries))
	}
	return n
}

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

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

func (m *ReplicateGroupStats_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Group != nil {
		l = m.Group.Size()
		n += 1 + l + sovBertyreplication(uint64(l))
	}
	return n
}

func sovBertyreplication(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozBertyreplication(x uint64) (n int) {
	return sovBertyreplication(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

func (m *ReplicatedGroup) 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 ErrIntOverflowBertyreplication
			}
			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: ReplicatedGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicatedGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignPub", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignPub = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 100:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 101:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 102:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataEntriesCount", wireType)
			}
			m.MetadataEntriesCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MetadataEntriesCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 103:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataLatestHead", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetadataLatestHead = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 104:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageEntriesCount", wireType)
			}
			m.MessageEntriesCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MessageEntriesCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 105:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageLatestHead", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MessageLatestHead = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyreplication(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ReplicatedGroupToken) 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 ErrIntOverflowBertyreplication
			}
			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: ReplicatedGroupToken: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicatedGroupToken: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicatedGroupPublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplicatedGroupPublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicatedGroup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReplicatedGroup == nil {
				m.ReplicatedGroup = &ReplicatedGroup{}
			}
			if err := m.ReplicatedGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenIssuer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenIssuer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				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 ErrInvalidLengthBertyreplication
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyreplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBertyreplication(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyreplication
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

var (
	ErrInvalidLengthBertyreplication        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBertyreplication          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBertyreplication = fmt.Errorf("proto: unexpected end of group")
)