// Code generated by protoc-gen-go. DO NOT EDIT.
// source: bazil.org/bazil/peer/wire/peer.proto

package wire

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

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

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

type VolumeSyncPullItem_Error int32

const (
	VolumeSyncPullItem_SUCCESS VolumeSyncPullItem_Error = 0
	// The path in the request did not refer to a directory.
	VolumeSyncPullItem_NOT_A_DIRECTORY VolumeSyncPullItem_Error = 1
)

var VolumeSyncPullItem_Error_name = map[int32]string{
	0: "SUCCESS",
	1: "NOT_A_DIRECTORY",
}

var VolumeSyncPullItem_Error_value = map[string]int32{
	"SUCCESS":         0,
	"NOT_A_DIRECTORY": 1,
}

func (x VolumeSyncPullItem_Error) String() string {
	return proto.EnumName(VolumeSyncPullItem_Error_name, int32(x))
}

func (VolumeSyncPullItem_Error) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{9, 0}
}

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

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

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

var xxx_messageInfo_PingRequest proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_PingResponse proto.InternalMessageInfo

type ObjectPutRequest struct {
	// Only set in the first streamed message.
	Key                  []byte   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ObjectPutRequest proto.InternalMessageInfo

func (m *ObjectPutRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ObjectPutRequest) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

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

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

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

var xxx_messageInfo_ObjectPutResponse proto.InternalMessageInfo

type ObjectGetRequest struct {
	Key                  []byte   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ObjectGetRequest proto.InternalMessageInfo

func (m *ObjectGetRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

type ObjectGetResponse struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ObjectGetResponse proto.InternalMessageInfo

func (m *ObjectGetResponse) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

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

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

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

var xxx_messageInfo_VolumeConnectRequest proto.InternalMessageInfo

func (m *VolumeConnectRequest) GetVolumeName() string {
	if m != nil {
		return m.VolumeName
	}
	return ""
}

type VolumeConnectResponse struct {
	VolumeID             []byte   `protobuf:"bytes,1,opt,name=volumeID,proto3" json:"volumeID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VolumeConnectResponse proto.InternalMessageInfo

func (m *VolumeConnectResponse) GetVolumeID() []byte {
	if m != nil {
		return m.VolumeID
	}
	return nil
}

type VolumeSyncPullRequest struct {
	VolumeID             []byte   `protobuf:"bytes,1,opt,name=volumeID,proto3" json:"volumeID,omitempty"`
	Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VolumeSyncPullRequest proto.InternalMessageInfo

func (m *VolumeSyncPullRequest) GetVolumeID() []byte {
	if m != nil {
		return m.VolumeID
	}
	return nil
}

func (m *VolumeSyncPullRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type VolumeSyncPullItem struct {
	// This is used to work around gRPC fixed error codes and error
	// strings.
	//
	// It can only be present in the first streamed message.
	// All other fields are to be ignored.
	Error VolumeSyncPullItem_Error `protobuf:"varint,1,opt,name=error,proto3,enum=bazil.peer.VolumeSyncPullItem_Error" json:"error,omitempty"`
	// Logical clocks in Dirents use small integers to identify peers.
	// This map connects those identifiers to globally unique peer
	// public keys.
	//
	// This can only be present in the first streamed message.
	Peers map[uint32][]byte `protobuf:"bytes,2,rep,name=peers,proto3" json:"peers,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Logical clock for the directory itself.
	//
	// This can only be present in the first streamed message.
	DirClock []byte `protobuf:"bytes,4,opt,name=dirClock,proto3" json:"dirClock,omitempty"`
	// Directory entries. More entries may follow in later streamed
	// messages. The entries are required to be in lexicographical
	// (bytewise) order, across all messages.
	Children             []*Dirent `protobuf:"bytes,3,rep,name=children,proto3" json:"children,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *VolumeSyncPullItem) Reset()         { *m = VolumeSyncPullItem{} }
func (m *VolumeSyncPullItem) String() string { return proto.CompactTextString(m) }
func (*VolumeSyncPullItem) ProtoMessage()    {}
func (*VolumeSyncPullItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{9}
}

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

var xxx_messageInfo_VolumeSyncPullItem proto.InternalMessageInfo

func (m *VolumeSyncPullItem) GetError() VolumeSyncPullItem_Error {
	if m != nil {
		return m.Error
	}
	return VolumeSyncPullItem_SUCCESS
}

func (m *VolumeSyncPullItem) GetPeers() map[uint32][]byte {
	if m != nil {
		return m.Peers
	}
	return nil
}

func (m *VolumeSyncPullItem) GetDirClock() []byte {
	if m != nil {
		return m.DirClock
	}
	return nil
}

func (m *VolumeSyncPullItem) GetChildren() []*Dirent {
	if m != nil {
		return m.Children
	}
	return nil
}

type Dirent struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Type:
	//	*Dirent_File
	//	*Dirent_Dir
	//	*Dirent_Tombstone
	Type                 isDirent_Type `protobuf_oneof:"type"`
	Clock                []byte        `protobuf:"bytes,4,opt,name=clock,proto3" json:"clock,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Dirent) Reset()         { *m = Dirent{} }
func (m *Dirent) String() string { return proto.CompactTextString(m) }
func (*Dirent) ProtoMessage()    {}
func (*Dirent) Descriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{10}
}

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

var xxx_messageInfo_Dirent proto.InternalMessageInfo

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

type isDirent_Type interface {
	isDirent_Type()
}

type Dirent_File struct {
	File *File `protobuf:"bytes,2,opt,name=file,proto3,oneof"`
}

type Dirent_Dir struct {
	Dir *Dir `protobuf:"bytes,3,opt,name=dir,proto3,oneof"`
}

type Dirent_Tombstone struct {
	Tombstone *Tombstone `protobuf:"bytes,5,opt,name=tombstone,proto3,oneof"`
}

func (*Dirent_File) isDirent_Type() {}

func (*Dirent_Dir) isDirent_Type() {}

func (*Dirent_Tombstone) isDirent_Type() {}

func (m *Dirent) GetType() isDirent_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Dirent) GetFile() *File {
	if x, ok := m.GetType().(*Dirent_File); ok {
		return x.File
	}
	return nil
}

func (m *Dirent) GetDir() *Dir {
	if x, ok := m.GetType().(*Dirent_Dir); ok {
		return x.Dir
	}
	return nil
}

func (m *Dirent) GetTombstone() *Tombstone {
	if x, ok := m.GetType().(*Dirent_Tombstone); ok {
		return x.Tombstone
	}
	return nil
}

func (m *Dirent) GetClock() []byte {
	if m != nil {
		return m.Clock
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Dirent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Dirent_File)(nil),
		(*Dirent_Dir)(nil),
		(*Dirent_Tombstone)(nil),
	}
}

type File struct {
	Manifest             *wire.Manifest `protobuf:"bytes,1,opt,name=manifest,proto3" json:"manifest,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *File) Reset()         { *m = File{} }
func (m *File) String() string { return proto.CompactTextString(m) }
func (*File) ProtoMessage()    {}
func (*File) Descriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{11}
}

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

var xxx_messageInfo_File proto.InternalMessageInfo

func (m *File) GetManifest() *wire.Manifest {
	if m != nil {
		return m.Manifest
	}
	return nil
}

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

func (m *Dir) Reset()         { *m = Dir{} }
func (m *Dir) String() string { return proto.CompactTextString(m) }
func (*Dir) ProtoMessage()    {}
func (*Dir) Descriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{12}
}

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

var xxx_messageInfo_Dir proto.InternalMessageInfo

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

func (m *Tombstone) Reset()         { *m = Tombstone{} }
func (m *Tombstone) String() string { return proto.CompactTextString(m) }
func (*Tombstone) ProtoMessage()    {}
func (*Tombstone) Descriptor() ([]byte, []int) {
	return fileDescriptor_f2a9abb617589e2c, []int{13}
}

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

var xxx_messageInfo_Tombstone proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("bazil.peer.VolumeSyncPullItem_Error", VolumeSyncPullItem_Error_name, VolumeSyncPullItem_Error_value)
	proto.RegisterType((*PingRequest)(nil), "bazil.peer.PingRequest")
	proto.RegisterType((*PingResponse)(nil), "bazil.peer.PingResponse")
	proto.RegisterType((*ObjectPutRequest)(nil), "bazil.peer.ObjectPutRequest")
	proto.RegisterType((*ObjectPutResponse)(nil), "bazil.peer.ObjectPutResponse")
	proto.RegisterType((*ObjectGetRequest)(nil), "bazil.peer.ObjectGetRequest")
	proto.RegisterType((*ObjectGetResponse)(nil), "bazil.peer.ObjectGetResponse")
	proto.RegisterType((*VolumeConnectRequest)(nil), "bazil.peer.VolumeConnectRequest")
	proto.RegisterType((*VolumeConnectResponse)(nil), "bazil.peer.VolumeConnectResponse")
	proto.RegisterType((*VolumeSyncPullRequest)(nil), "bazil.peer.VolumeSyncPullRequest")
	proto.RegisterType((*VolumeSyncPullItem)(nil), "bazil.peer.VolumeSyncPullItem")
	proto.RegisterMapType((map[uint32][]byte)(nil), "bazil.peer.VolumeSyncPullItem.PeersEntry")
	proto.RegisterType((*Dirent)(nil), "bazil.peer.Dirent")
	proto.RegisterType((*File)(nil), "bazil.peer.File")
	proto.RegisterType((*Dir)(nil), "bazil.peer.Dir")
	proto.RegisterType((*Tombstone)(nil), "bazil.peer.Tombstone")
}

func init() {
	proto.RegisterFile("bazil.org/bazil/peer/wire/peer.proto", fileDescriptor_f2a9abb617589e2c)
}

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

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

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

// PeerClient is the client API for Peer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PeerClient interface {
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
	ObjectPut(ctx context.Context, opts ...grpc.CallOption) (Peer_ObjectPutClient, error)
	ObjectGet(ctx context.Context, in *ObjectGetRequest, opts ...grpc.CallOption) (Peer_ObjectGetClient, error)
	VolumeConnect(ctx context.Context, in *VolumeConnectRequest, opts ...grpc.CallOption) (*VolumeConnectResponse, error)
	VolumeSyncPull(ctx context.Context, in *VolumeSyncPullRequest, opts ...grpc.CallOption) (Peer_VolumeSyncPullClient, error)
}

type peerClient struct {
	cc *grpc.ClientConn
}

func NewPeerClient(cc *grpc.ClientConn) PeerClient {
	return &peerClient{cc}
}

func (c *peerClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
	out := new(PingResponse)
	err := c.cc.Invoke(ctx, "/bazil.peer.Peer/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *peerClient) ObjectPut(ctx context.Context, opts ...grpc.CallOption) (Peer_ObjectPutClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Peer_serviceDesc.Streams[0], "/bazil.peer.Peer/ObjectPut", opts...)
	if err != nil {
		return nil, err
	}
	x := &peerObjectPutClient{stream}
	return x, nil
}

type Peer_ObjectPutClient interface {
	Send(*ObjectPutRequest) error
	CloseAndRecv() (*ObjectPutResponse, error)
	grpc.ClientStream
}

type peerObjectPutClient struct {
	grpc.ClientStream
}

func (x *peerObjectPutClient) Send(m *ObjectPutRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *peerObjectPutClient) CloseAndRecv() (*ObjectPutResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(ObjectPutResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *peerClient) ObjectGet(ctx context.Context, in *ObjectGetRequest, opts ...grpc.CallOption) (Peer_ObjectGetClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Peer_serviceDesc.Streams[1], "/bazil.peer.Peer/ObjectGet", opts...)
	if err != nil {
		return nil, err
	}
	x := &peerObjectGetClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Peer_ObjectGetClient interface {
	Recv() (*ObjectGetResponse, error)
	grpc.ClientStream
}

type peerObjectGetClient struct {
	grpc.ClientStream
}

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

func (c *peerClient) VolumeConnect(ctx context.Context, in *VolumeConnectRequest, opts ...grpc.CallOption) (*VolumeConnectResponse, error) {
	out := new(VolumeConnectResponse)
	err := c.cc.Invoke(ctx, "/bazil.peer.Peer/VolumeConnect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *peerClient) VolumeSyncPull(ctx context.Context, in *VolumeSyncPullRequest, opts ...grpc.CallOption) (Peer_VolumeSyncPullClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Peer_serviceDesc.Streams[2], "/bazil.peer.Peer/VolumeSyncPull", opts...)
	if err != nil {
		return nil, err
	}
	x := &peerVolumeSyncPullClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Peer_VolumeSyncPullClient interface {
	Recv() (*VolumeSyncPullItem, error)
	grpc.ClientStream
}

type peerVolumeSyncPullClient struct {
	grpc.ClientStream
}

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

// PeerServer is the server API for Peer service.
type PeerServer interface {
	Ping(context.Context, *PingRequest) (*PingResponse, error)
	ObjectPut(Peer_ObjectPutServer) error
	ObjectGet(*ObjectGetRequest, Peer_ObjectGetServer) error
	VolumeConnect(context.Context, *VolumeConnectRequest) (*VolumeConnectResponse, error)
	VolumeSyncPull(*VolumeSyncPullRequest, Peer_VolumeSyncPullServer) error
}

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

func (*UnimplementedPeerServer) Ping(ctx context.Context, req *PingRequest) (*PingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (*UnimplementedPeerServer) ObjectPut(srv Peer_ObjectPutServer) error {
	return status.Errorf(codes.Unimplemented, "method ObjectPut not implemented")
}
func (*UnimplementedPeerServer) ObjectGet(req *ObjectGetRequest, srv Peer_ObjectGetServer) error {
	return status.Errorf(codes.Unimplemented, "method ObjectGet not implemented")
}
func (*UnimplementedPeerServer) VolumeConnect(ctx context.Context, req *VolumeConnectRequest) (*VolumeConnectResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VolumeConnect not implemented")
}
func (*UnimplementedPeerServer) VolumeSyncPull(req *VolumeSyncPullRequest, srv Peer_VolumeSyncPullServer) error {
	return status.Errorf(codes.Unimplemented, "method VolumeSyncPull not implemented")
}

func RegisterPeerServer(s *grpc.Server, srv PeerServer) {
	s.RegisterService(&_Peer_serviceDesc, srv)
}

func _Peer_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PeerServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bazil.peer.Peer/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PeerServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Peer_ObjectPut_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(PeerServer).ObjectPut(&peerObjectPutServer{stream})
}

type Peer_ObjectPutServer interface {
	SendAndClose(*ObjectPutResponse) error
	Recv() (*ObjectPutRequest, error)
	grpc.ServerStream
}

type peerObjectPutServer struct {
	grpc.ServerStream
}

func (x *peerObjectPutServer) SendAndClose(m *ObjectPutResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *peerObjectPutServer) Recv() (*ObjectPutRequest, error) {
	m := new(ObjectPutRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Peer_ObjectGet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ObjectGetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PeerServer).ObjectGet(m, &peerObjectGetServer{stream})
}

type Peer_ObjectGetServer interface {
	Send(*ObjectGetResponse) error
	grpc.ServerStream
}

type peerObjectGetServer struct {
	grpc.ServerStream
}

func (x *peerObjectGetServer) Send(m *ObjectGetResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Peer_VolumeConnect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VolumeConnectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PeerServer).VolumeConnect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bazil.peer.Peer/VolumeConnect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PeerServer).VolumeConnect(ctx, req.(*VolumeConnectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Peer_VolumeSyncPull_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VolumeSyncPullRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PeerServer).VolumeSyncPull(m, &peerVolumeSyncPullServer{stream})
}

type Peer_VolumeSyncPullServer interface {
	Send(*VolumeSyncPullItem) error
	grpc.ServerStream
}

type peerVolumeSyncPullServer struct {
	grpc.ServerStream
}

func (x *peerVolumeSyncPullServer) Send(m *VolumeSyncPullItem) error {
	return x.ServerStream.SendMsg(m)
}

var _Peer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "bazil.peer.Peer",
	HandlerType: (*PeerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _Peer_Ping_Handler,
		},
		{
			MethodName: "VolumeConnect",
			Handler:    _Peer_VolumeConnect_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ObjectPut",
			Handler:       _Peer_ObjectPut_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ObjectGet",
			Handler:       _Peer_ObjectGet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "VolumeSyncPull",
			Handler:       _Peer_VolumeSyncPull_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "bazil.org/bazil/peer/wire/peer.proto",
}
