zrepl/replication/logic/pdu/pdu.pb.go

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

package pdu

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

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

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

type Tri int32

const (
	Tri_DontCare Tri = 0
	Tri_False    Tri = 1
	Tri_True     Tri = 2
)

var Tri_name = map[int32]string{
	0: "DontCare",
	1: "False",
	2: "True",
}
var Tri_value = map[string]int32{
	"DontCare": 0,
	"False":    1,
	"True":     2,
}

func (x Tri) String() string {
	return proto.EnumName(Tri_name, int32(x))
}
func (Tri) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{0}
}

type ReplicationGuaranteeKind int32

const (
	ReplicationGuaranteeKind_GuaranteeInvalid                ReplicationGuaranteeKind = 0
	ReplicationGuaranteeKind_GuaranteeResumability           ReplicationGuaranteeKind = 1
	ReplicationGuaranteeKind_GuaranteeIncrementalReplication ReplicationGuaranteeKind = 2
	ReplicationGuaranteeKind_GuaranteeNothing                ReplicationGuaranteeKind = 3
)

var ReplicationGuaranteeKind_name = map[int32]string{
	0: "GuaranteeInvalid",
	1: "GuaranteeResumability",
	2: "GuaranteeIncrementalReplication",
	3: "GuaranteeNothing",
}
var ReplicationGuaranteeKind_value = map[string]int32{
	"GuaranteeInvalid":                0,
	"GuaranteeResumability":           1,
	"GuaranteeIncrementalReplication": 2,
	"GuaranteeNothing":                3,
}

func (x ReplicationGuaranteeKind) String() string {
	return proto.EnumName(ReplicationGuaranteeKind_name, int32(x))
}
func (ReplicationGuaranteeKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{1}
}

type FilesystemVersion_VersionType int32

const (
	FilesystemVersion_Snapshot FilesystemVersion_VersionType = 0
	FilesystemVersion_Bookmark FilesystemVersion_VersionType = 1
)

var FilesystemVersion_VersionType_name = map[int32]string{
	0: "Snapshot",
	1: "Bookmark",
}
var FilesystemVersion_VersionType_value = map[string]int32{
	"Snapshot": 0,
	"Bookmark": 1,
}

func (x FilesystemVersion_VersionType) String() string {
	return proto.EnumName(FilesystemVersion_VersionType_name, int32(x))
}
func (FilesystemVersion_VersionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{5, 0}
}

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

func (m *ListFilesystemReq) Reset()         { *m = ListFilesystemReq{} }
func (m *ListFilesystemReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemReq) ProtoMessage()    {}
func (*ListFilesystemReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{0}
}
func (m *ListFilesystemReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemReq.Unmarshal(m, b)
}
func (m *ListFilesystemReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemReq.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemReq.Merge(dst, src)
}
func (m *ListFilesystemReq) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemReq.Size(m)
}
func (m *ListFilesystemReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemReq.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemReq proto.InternalMessageInfo

type ListFilesystemRes struct {
	Filesystems          []*Filesystem `protobuf:"bytes,1,rep,name=Filesystems,proto3" json:"Filesystems,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ListFilesystemRes) Reset()         { *m = ListFilesystemRes{} }
func (m *ListFilesystemRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemRes) ProtoMessage()    {}
func (*ListFilesystemRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{1}
}
func (m *ListFilesystemRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemRes.Unmarshal(m, b)
}
func (m *ListFilesystemRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemRes.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemRes.Merge(dst, src)
}
func (m *ListFilesystemRes) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemRes.Size(m)
}
func (m *ListFilesystemRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemRes.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemRes proto.InternalMessageInfo

func (m *ListFilesystemRes) GetFilesystems() []*Filesystem {
	if m != nil {
		return m.Filesystems
	}
	return nil
}

type Filesystem struct {
	Path                 string   `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
	ResumeToken          string   `protobuf:"bytes,2,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
	IsPlaceholder        bool     `protobuf:"varint,3,opt,name=IsPlaceholder,proto3" json:"IsPlaceholder,omitempty"`
	IsEncrypted          bool     `protobuf:"varint,4,opt,name=IsEncrypted,proto3" json:"IsEncrypted,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Filesystem) Reset()         { *m = Filesystem{} }
func (m *Filesystem) String() string { return proto.CompactTextString(m) }
func (*Filesystem) ProtoMessage()    {}
func (*Filesystem) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{2}
}
func (m *Filesystem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Filesystem.Unmarshal(m, b)
}
func (m *Filesystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Filesystem.Marshal(b, m, deterministic)
}
func (dst *Filesystem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Filesystem.Merge(dst, src)
}
func (m *Filesystem) XXX_Size() int {
	return xxx_messageInfo_Filesystem.Size(m)
}
func (m *Filesystem) XXX_DiscardUnknown() {
	xxx_messageInfo_Filesystem.DiscardUnknown(m)
}

var xxx_messageInfo_Filesystem proto.InternalMessageInfo

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

func (m *Filesystem) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

func (m *Filesystem) GetIsPlaceholder() bool {
	if m != nil {
		return m.IsPlaceholder
	}
	return false
}

func (m *Filesystem) GetIsEncrypted() bool {
	if m != nil {
		return m.IsEncrypted
	}
	return false
}

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

func (m *ListFilesystemVersionsReq) Reset()         { *m = ListFilesystemVersionsReq{} }
func (m *ListFilesystemVersionsReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsReq) ProtoMessage()    {}
func (*ListFilesystemVersionsReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{3}
}
func (m *ListFilesystemVersionsReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemVersionsReq.Unmarshal(m, b)
}
func (m *ListFilesystemVersionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemVersionsReq.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemVersionsReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemVersionsReq.Merge(dst, src)
}
func (m *ListFilesystemVersionsReq) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemVersionsReq.Size(m)
}
func (m *ListFilesystemVersionsReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemVersionsReq.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemVersionsReq proto.InternalMessageInfo

func (m *ListFilesystemVersionsReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

type ListFilesystemVersionsRes struct {
	Versions             []*FilesystemVersion `protobuf:"bytes,1,rep,name=Versions,proto3" json:"Versions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ListFilesystemVersionsRes) Reset()         { *m = ListFilesystemVersionsRes{} }
func (m *ListFilesystemVersionsRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsRes) ProtoMessage()    {}
func (*ListFilesystemVersionsRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{4}
}
func (m *ListFilesystemVersionsRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemVersionsRes.Unmarshal(m, b)
}
func (m *ListFilesystemVersionsRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemVersionsRes.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemVersionsRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemVersionsRes.Merge(dst, src)
}
func (m *ListFilesystemVersionsRes) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemVersionsRes.Size(m)
}
func (m *ListFilesystemVersionsRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemVersionsRes.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemVersionsRes proto.InternalMessageInfo

func (m *ListFilesystemVersionsRes) GetVersions() []*FilesystemVersion {
	if m != nil {
		return m.Versions
	}
	return nil
}

type FilesystemVersion struct {
	Type                 FilesystemVersion_VersionType `protobuf:"varint,1,opt,name=Type,proto3,enum=FilesystemVersion_VersionType" json:"Type,omitempty"`
	Name                 string                        `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	Guid                 uint64                        `protobuf:"varint,3,opt,name=Guid,proto3" json:"Guid,omitempty"`
	CreateTXG            uint64                        `protobuf:"varint,4,opt,name=CreateTXG,proto3" json:"CreateTXG,omitempty"`
	Creation             string                        `protobuf:"bytes,5,opt,name=Creation,proto3" json:"Creation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *FilesystemVersion) Reset()         { *m = FilesystemVersion{} }
func (m *FilesystemVersion) String() string { return proto.CompactTextString(m) }
func (*FilesystemVersion) ProtoMessage()    {}
func (*FilesystemVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{5}
}
func (m *FilesystemVersion) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FilesystemVersion.Unmarshal(m, b)
}
func (m *FilesystemVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FilesystemVersion.Marshal(b, m, deterministic)
}
func (dst *FilesystemVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FilesystemVersion.Merge(dst, src)
}
func (m *FilesystemVersion) XXX_Size() int {
	return xxx_messageInfo_FilesystemVersion.Size(m)
}
func (m *FilesystemVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_FilesystemVersion.DiscardUnknown(m)
}

var xxx_messageInfo_FilesystemVersion proto.InternalMessageInfo

func (m *FilesystemVersion) GetType() FilesystemVersion_VersionType {
	if m != nil {
		return m.Type
	}
	return FilesystemVersion_Snapshot
}

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

func (m *FilesystemVersion) GetGuid() uint64 {
	if m != nil {
		return m.Guid
	}
	return 0
}

func (m *FilesystemVersion) GetCreateTXG() uint64 {
	if m != nil {
		return m.CreateTXG
	}
	return 0
}

func (m *FilesystemVersion) GetCreation() string {
	if m != nil {
		return m.Creation
	}
	return ""
}

type SendReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	// May be empty / null to request a full transfer of To
	From *FilesystemVersion `protobuf:"bytes,2,opt,name=From,proto3" json:"From,omitempty"`
	To   *FilesystemVersion `protobuf:"bytes,3,opt,name=To,proto3" json:"To,omitempty"`
	// If ResumeToken is not empty, the resume token that CAN be used for 'zfs
	// send' by the sender. The sender MUST indicate use of ResumeToken in the
	// reply message SendRes.UsedResumeToken If it does not work, the sender
	// SHOULD clear the resume token on their side and use From and To instead If
	// ResumeToken is not empty, the GUIDs of From and To MUST correspond to those
	// encoded in the ResumeToken. Otherwise, the Sender MUST return an error.
	ResumeToken          string             `protobuf:"bytes,4,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
	Encrypted            Tri                `protobuf:"varint,5,opt,name=Encrypted,proto3,enum=Tri" json:"Encrypted,omitempty"`
	DryRun               bool               `protobuf:"varint,6,opt,name=DryRun,proto3" json:"DryRun,omitempty"`
	ReplicationConfig    *ReplicationConfig `protobuf:"bytes,7,opt,name=ReplicationConfig,proto3" json:"ReplicationConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SendReq) Reset()         { *m = SendReq{} }
func (m *SendReq) String() string { return proto.CompactTextString(m) }
func (*SendReq) ProtoMessage()    {}
func (*SendReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{6}
}
func (m *SendReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendReq.Unmarshal(m, b)
}
func (m *SendReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendReq.Marshal(b, m, deterministic)
}
func (dst *SendReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendReq.Merge(dst, src)
}
func (m *SendReq) XXX_Size() int {
	return xxx_messageInfo_SendReq.Size(m)
}
func (m *SendReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SendReq.DiscardUnknown(m)
}

var xxx_messageInfo_SendReq proto.InternalMessageInfo

func (m *SendReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *SendReq) GetFrom() *FilesystemVersion {
	if m != nil {
		return m.From
	}
	return nil
}

func (m *SendReq) GetTo() *FilesystemVersion {
	if m != nil {
		return m.To
	}
	return nil
}

func (m *SendReq) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

func (m *SendReq) GetEncrypted() Tri {
	if m != nil {
		return m.Encrypted
	}
	return Tri_DontCare
}

func (m *SendReq) GetDryRun() bool {
	if m != nil {
		return m.DryRun
	}
	return false
}

func (m *SendReq) GetReplicationConfig() *ReplicationConfig {
	if m != nil {
		return m.ReplicationConfig
	}
	return nil
}

type ReplicationConfig struct {
	Protection           *ReplicationConfigProtection `protobuf:"bytes,1,opt,name=protection,proto3" json:"protection,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *ReplicationConfig) Reset()         { *m = ReplicationConfig{} }
func (m *ReplicationConfig) String() string { return proto.CompactTextString(m) }
func (*ReplicationConfig) ProtoMessage()    {}
func (*ReplicationConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{7}
}
func (m *ReplicationConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplicationConfig.Unmarshal(m, b)
}
func (m *ReplicationConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplicationConfig.Marshal(b, m, deterministic)
}
func (dst *ReplicationConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationConfig.Merge(dst, src)
}
func (m *ReplicationConfig) XXX_Size() int {
	return xxx_messageInfo_ReplicationConfig.Size(m)
}
func (m *ReplicationConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationConfig proto.InternalMessageInfo

func (m *ReplicationConfig) GetProtection() *ReplicationConfigProtection {
	if m != nil {
		return m.Protection
	}
	return nil
}

type ReplicationConfigProtection struct {
	Initial              ReplicationGuaranteeKind `protobuf:"varint,1,opt,name=Initial,proto3,enum=ReplicationGuaranteeKind" json:"Initial,omitempty"`
	Incremental          ReplicationGuaranteeKind `protobuf:"varint,2,opt,name=Incremental,proto3,enum=ReplicationGuaranteeKind" json:"Incremental,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *ReplicationConfigProtection) Reset()         { *m = ReplicationConfigProtection{} }
func (m *ReplicationConfigProtection) String() string { return proto.CompactTextString(m) }
func (*ReplicationConfigProtection) ProtoMessage()    {}
func (*ReplicationConfigProtection) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{8}
}
func (m *ReplicationConfigProtection) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplicationConfigProtection.Unmarshal(m, b)
}
func (m *ReplicationConfigProtection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplicationConfigProtection.Marshal(b, m, deterministic)
}
func (dst *ReplicationConfigProtection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationConfigProtection.Merge(dst, src)
}
func (m *ReplicationConfigProtection) XXX_Size() int {
	return xxx_messageInfo_ReplicationConfigProtection.Size(m)
}
func (m *ReplicationConfigProtection) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationConfigProtection.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationConfigProtection proto.InternalMessageInfo

func (m *ReplicationConfigProtection) GetInitial() ReplicationGuaranteeKind {
	if m != nil {
		return m.Initial
	}
	return ReplicationGuaranteeKind_GuaranteeInvalid
}

func (m *ReplicationConfigProtection) GetIncremental() ReplicationGuaranteeKind {
	if m != nil {
		return m.Incremental
	}
	return ReplicationGuaranteeKind_GuaranteeInvalid
}

type Property struct {
	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Property) Reset()         { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage()    {}
func (*Property) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{9}
}
func (m *Property) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Property.Unmarshal(m, b)
}
func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Property.Marshal(b, m, deterministic)
}
func (dst *Property) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Property.Merge(dst, src)
}
func (m *Property) XXX_Size() int {
	return xxx_messageInfo_Property.Size(m)
}
func (m *Property) XXX_DiscardUnknown() {
	xxx_messageInfo_Property.DiscardUnknown(m)
}

var xxx_messageInfo_Property proto.InternalMessageInfo

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

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

type SendRes struct {
	// Whether the resume token provided in the request has been used or not.
	// If the SendReq.ResumeToken == "", this field has no meaning.
	UsedResumeToken bool `protobuf:"varint,2,opt,name=UsedResumeToken,proto3" json:"UsedResumeToken,omitempty"`
	// Expected stream size determined by dry run, not exact.
	// 0 indicates that for the given SendReq, no size estimate could be made.
	ExpectedSize         int64       `protobuf:"varint,3,opt,name=ExpectedSize,proto3" json:"ExpectedSize,omitempty"`
	Properties           []*Property `protobuf:"bytes,4,rep,name=Properties,proto3" json:"Properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SendRes) Reset()         { *m = SendRes{} }
func (m *SendRes) String() string { return proto.CompactTextString(m) }
func (*SendRes) ProtoMessage()    {}
func (*SendRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{10}
}
func (m *SendRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendRes.Unmarshal(m, b)
}
func (m *SendRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendRes.Marshal(b, m, deterministic)
}
func (dst *SendRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendRes.Merge(dst, src)
}
func (m *SendRes) XXX_Size() int {
	return xxx_messageInfo_SendRes.Size(m)
}
func (m *SendRes) XXX_DiscardUnknown() {
	xxx_messageInfo_SendRes.DiscardUnknown(m)
}

var xxx_messageInfo_SendRes proto.InternalMessageInfo

func (m *SendRes) GetUsedResumeToken() bool {
	if m != nil {
		return m.UsedResumeToken
	}
	return false
}

func (m *SendRes) GetExpectedSize() int64 {
	if m != nil {
		return m.ExpectedSize
	}
	return 0
}

func (m *SendRes) GetProperties() []*Property {
	if m != nil {
		return m.Properties
	}
	return nil
}

type SendCompletedReq struct {
	OriginalReq          *SendReq `protobuf:"bytes,2,opt,name=OriginalReq,proto3" json:"OriginalReq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SendCompletedReq) Reset()         { *m = SendCompletedReq{} }
func (m *SendCompletedReq) String() string { return proto.CompactTextString(m) }
func (*SendCompletedReq) ProtoMessage()    {}
func (*SendCompletedReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{11}
}
func (m *SendCompletedReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendCompletedReq.Unmarshal(m, b)
}
func (m *SendCompletedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendCompletedReq.Marshal(b, m, deterministic)
}
func (dst *SendCompletedReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendCompletedReq.Merge(dst, src)
}
func (m *SendCompletedReq) XXX_Size() int {
	return xxx_messageInfo_SendCompletedReq.Size(m)
}
func (m *SendCompletedReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SendCompletedReq.DiscardUnknown(m)
}

var xxx_messageInfo_SendCompletedReq proto.InternalMessageInfo

func (m *SendCompletedReq) GetOriginalReq() *SendReq {
	if m != nil {
		return m.OriginalReq
	}
	return nil
}

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

func (m *SendCompletedRes) Reset()         { *m = SendCompletedRes{} }
func (m *SendCompletedRes) String() string { return proto.CompactTextString(m) }
func (*SendCompletedRes) ProtoMessage()    {}
func (*SendCompletedRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{12}
}
func (m *SendCompletedRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendCompletedRes.Unmarshal(m, b)
}
func (m *SendCompletedRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendCompletedRes.Marshal(b, m, deterministic)
}
func (dst *SendCompletedRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendCompletedRes.Merge(dst, src)
}
func (m *SendCompletedRes) XXX_Size() int {
	return xxx_messageInfo_SendCompletedRes.Size(m)
}
func (m *SendCompletedRes) XXX_DiscardUnknown() {
	xxx_messageInfo_SendCompletedRes.DiscardUnknown(m)
}

var xxx_messageInfo_SendCompletedRes proto.InternalMessageInfo

type ReceiveReq struct {
	Filesystem string             `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	To         *FilesystemVersion `protobuf:"bytes,2,opt,name=To,proto3" json:"To,omitempty"`
	// If true, the receiver should clear the resume token before performing the
	// zfs recv of the stream in the request
	ClearResumeToken     bool               `protobuf:"varint,3,opt,name=ClearResumeToken,proto3" json:"ClearResumeToken,omitempty"`
	ReplicationConfig    *ReplicationConfig `protobuf:"bytes,4,opt,name=ReplicationConfig,proto3" json:"ReplicationConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ReceiveReq) Reset()         { *m = ReceiveReq{} }
func (m *ReceiveReq) String() string { return proto.CompactTextString(m) }
func (*ReceiveReq) ProtoMessage()    {}
func (*ReceiveReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{13}
}
func (m *ReceiveReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiveReq.Unmarshal(m, b)
}
func (m *ReceiveReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiveReq.Marshal(b, m, deterministic)
}
func (dst *ReceiveReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiveReq.Merge(dst, src)
}
func (m *ReceiveReq) XXX_Size() int {
	return xxx_messageInfo_ReceiveReq.Size(m)
}
func (m *ReceiveReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiveReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiveReq proto.InternalMessageInfo

func (m *ReceiveReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *ReceiveReq) GetTo() *FilesystemVersion {
	if m != nil {
		return m.To
	}
	return nil
}

func (m *ReceiveReq) GetClearResumeToken() bool {
	if m != nil {
		return m.ClearResumeToken
	}
	return false
}

func (m *ReceiveReq) GetReplicationConfig() *ReplicationConfig {
	if m != nil {
		return m.ReplicationConfig
	}
	return nil
}

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

func (m *ReceiveRes) Reset()         { *m = ReceiveRes{} }
func (m *ReceiveRes) String() string { return proto.CompactTextString(m) }
func (*ReceiveRes) ProtoMessage()    {}
func (*ReceiveRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{14}
}
func (m *ReceiveRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiveRes.Unmarshal(m, b)
}
func (m *ReceiveRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiveRes.Marshal(b, m, deterministic)
}
func (dst *ReceiveRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiveRes.Merge(dst, src)
}
func (m *ReceiveRes) XXX_Size() int {
	return xxx_messageInfo_ReceiveRes.Size(m)
}
func (m *ReceiveRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiveRes.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiveRes proto.InternalMessageInfo

type DestroySnapshotsReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	// Path to filesystem, snapshot or bookmark to be destroyed
	Snapshots            []*FilesystemVersion `protobuf:"bytes,2,rep,name=Snapshots,proto3" json:"Snapshots,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *DestroySnapshotsReq) Reset()         { *m = DestroySnapshotsReq{} }
func (m *DestroySnapshotsReq) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotsReq) ProtoMessage()    {}
func (*DestroySnapshotsReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{15}
}
func (m *DestroySnapshotsReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DestroySnapshotsReq.Unmarshal(m, b)
}
func (m *DestroySnapshotsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DestroySnapshotsReq.Marshal(b, m, deterministic)
}
func (dst *DestroySnapshotsReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DestroySnapshotsReq.Merge(dst, src)
}
func (m *DestroySnapshotsReq) XXX_Size() int {
	return xxx_messageInfo_DestroySnapshotsReq.Size(m)
}
func (m *DestroySnapshotsReq) XXX_DiscardUnknown() {
	xxx_messageInfo_DestroySnapshotsReq.DiscardUnknown(m)
}

var xxx_messageInfo_DestroySnapshotsReq proto.InternalMessageInfo

func (m *DestroySnapshotsReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *DestroySnapshotsReq) GetSnapshots() []*FilesystemVersion {
	if m != nil {
		return m.Snapshots
	}
	return nil
}

type DestroySnapshotRes struct {
	Snapshot             *FilesystemVersion `protobuf:"bytes,1,opt,name=Snapshot,proto3" json:"Snapshot,omitempty"`
	Error                string             `protobuf:"bytes,2,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *DestroySnapshotRes) Reset()         { *m = DestroySnapshotRes{} }
func (m *DestroySnapshotRes) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotRes) ProtoMessage()    {}
func (*DestroySnapshotRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{16}
}
func (m *DestroySnapshotRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DestroySnapshotRes.Unmarshal(m, b)
}
func (m *DestroySnapshotRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DestroySnapshotRes.Marshal(b, m, deterministic)
}
func (dst *DestroySnapshotRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DestroySnapshotRes.Merge(dst, src)
}
func (m *DestroySnapshotRes) XXX_Size() int {
	return xxx_messageInfo_DestroySnapshotRes.Size(m)
}
func (m *DestroySnapshotRes) XXX_DiscardUnknown() {
	xxx_messageInfo_DestroySnapshotRes.DiscardUnknown(m)
}

var xxx_messageInfo_DestroySnapshotRes proto.InternalMessageInfo

func (m *DestroySnapshotRes) GetSnapshot() *FilesystemVersion {
	if m != nil {
		return m.Snapshot
	}
	return nil
}

func (m *DestroySnapshotRes) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type DestroySnapshotsRes struct {
	Results              []*DestroySnapshotRes `protobuf:"bytes,1,rep,name=Results,proto3" json:"Results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *DestroySnapshotsRes) Reset()         { *m = DestroySnapshotsRes{} }
func (m *DestroySnapshotsRes) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotsRes) ProtoMessage()    {}
func (*DestroySnapshotsRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{17}
}
func (m *DestroySnapshotsRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DestroySnapshotsRes.Unmarshal(m, b)
}
func (m *DestroySnapshotsRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DestroySnapshotsRes.Marshal(b, m, deterministic)
}
func (dst *DestroySnapshotsRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DestroySnapshotsRes.Merge(dst, src)
}
func (m *DestroySnapshotsRes) XXX_Size() int {
	return xxx_messageInfo_DestroySnapshotsRes.Size(m)
}
func (m *DestroySnapshotsRes) XXX_DiscardUnknown() {
	xxx_messageInfo_DestroySnapshotsRes.DiscardUnknown(m)
}

var xxx_messageInfo_DestroySnapshotsRes proto.InternalMessageInfo

func (m *DestroySnapshotsRes) GetResults() []*DestroySnapshotRes {
	if m != nil {
		return m.Results
	}
	return nil
}

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

func (m *ReplicationCursorReq) Reset()         { *m = ReplicationCursorReq{} }
func (m *ReplicationCursorReq) String() string { return proto.CompactTextString(m) }
func (*ReplicationCursorReq) ProtoMessage()    {}
func (*ReplicationCursorReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{18}
}
func (m *ReplicationCursorReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplicationCursorReq.Unmarshal(m, b)
}
func (m *ReplicationCursorReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplicationCursorReq.Marshal(b, m, deterministic)
}
func (dst *ReplicationCursorReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationCursorReq.Merge(dst, src)
}
func (m *ReplicationCursorReq) XXX_Size() int {
	return xxx_messageInfo_ReplicationCursorReq.Size(m)
}
func (m *ReplicationCursorReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationCursorReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationCursorReq proto.InternalMessageInfo

func (m *ReplicationCursorReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

type ReplicationCursorRes struct {
	// Types that are valid to be assigned to Result:
	//	*ReplicationCursorRes_Guid
	//	*ReplicationCursorRes_Notexist
	Result               isReplicationCursorRes_Result `protobuf_oneof:"Result"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *ReplicationCursorRes) Reset()         { *m = ReplicationCursorRes{} }
func (m *ReplicationCursorRes) String() string { return proto.CompactTextString(m) }
func (*ReplicationCursorRes) ProtoMessage()    {}
func (*ReplicationCursorRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{19}
}
func (m *ReplicationCursorRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplicationCursorRes.Unmarshal(m, b)
}
func (m *ReplicationCursorRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplicationCursorRes.Marshal(b, m, deterministic)
}
func (dst *ReplicationCursorRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationCursorRes.Merge(dst, src)
}
func (m *ReplicationCursorRes) XXX_Size() int {
	return xxx_messageInfo_ReplicationCursorRes.Size(m)
}
func (m *ReplicationCursorRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationCursorRes.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationCursorRes proto.InternalMessageInfo

type isReplicationCursorRes_Result interface {
	isReplicationCursorRes_Result()
}

type ReplicationCursorRes_Guid struct {
	Guid uint64 `protobuf:"varint,1,opt,name=Guid,proto3,oneof"`
}

type ReplicationCursorRes_Notexist struct {
	Notexist bool `protobuf:"varint,2,opt,name=Notexist,proto3,oneof"`
}

func (*ReplicationCursorRes_Guid) isReplicationCursorRes_Result() {}

func (*ReplicationCursorRes_Notexist) isReplicationCursorRes_Result() {}

func (m *ReplicationCursorRes) GetResult() isReplicationCursorRes_Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *ReplicationCursorRes) GetGuid() uint64 {
	if x, ok := m.GetResult().(*ReplicationCursorRes_Guid); ok {
		return x.Guid
	}
	return 0
}

func (m *ReplicationCursorRes) GetNotexist() bool {
	if x, ok := m.GetResult().(*ReplicationCursorRes_Notexist); ok {
		return x.Notexist
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ReplicationCursorRes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ReplicationCursorRes_OneofMarshaler, _ReplicationCursorRes_OneofUnmarshaler, _ReplicationCursorRes_OneofSizer, []interface{}{
		(*ReplicationCursorRes_Guid)(nil),
		(*ReplicationCursorRes_Notexist)(nil),
	}
}

func _ReplicationCursorRes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ReplicationCursorRes)
	// Result
	switch x := m.Result.(type) {
	case *ReplicationCursorRes_Guid:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Guid))
	case *ReplicationCursorRes_Notexist:
		t := uint64(0)
		if x.Notexist {
			t = 1
		}
		b.EncodeVarint(2<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case nil:
	default:
		return fmt.Errorf("ReplicationCursorRes.Result has unexpected type %T", x)
	}
	return nil
}

func _ReplicationCursorRes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ReplicationCursorRes)
	switch tag {
	case 1: // Result.Guid
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Result = &ReplicationCursorRes_Guid{x}
		return true, err
	case 2: // Result.Notexist
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Result = &ReplicationCursorRes_Notexist{x != 0}
		return true, err
	default:
		return false, nil
	}
}

func _ReplicationCursorRes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ReplicationCursorRes)
	// Result
	switch x := m.Result.(type) {
	case *ReplicationCursorRes_Guid:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Guid))
	case *ReplicationCursorRes_Notexist:
		n += 1 // tag and wire
		n += 1
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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

func (m *PingReq) Reset()         { *m = PingReq{} }
func (m *PingReq) String() string { return proto.CompactTextString(m) }
func (*PingReq) ProtoMessage()    {}
func (*PingReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{20}
}
func (m *PingReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PingReq.Unmarshal(m, b)
}
func (m *PingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PingReq.Marshal(b, m, deterministic)
}
func (dst *PingReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingReq.Merge(dst, src)
}
func (m *PingReq) XXX_Size() int {
	return xxx_messageInfo_PingReq.Size(m)
}
func (m *PingReq) XXX_DiscardUnknown() {
	xxx_messageInfo_PingReq.DiscardUnknown(m)
}

var xxx_messageInfo_PingReq proto.InternalMessageInfo

func (m *PingReq) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type PingRes struct {
	// Echo must be PingReq.Message
	Echo                 string   `protobuf:"bytes,1,opt,name=Echo,proto3" json:"Echo,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PingRes) Reset()         { *m = PingRes{} }
func (m *PingRes) String() string { return proto.CompactTextString(m) }
func (*PingRes) ProtoMessage()    {}
func (*PingRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_616c27178643eca4, []int{21}
}
func (m *PingRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PingRes.Unmarshal(m, b)
}
func (m *PingRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PingRes.Marshal(b, m, deterministic)
}
func (dst *PingRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingRes.Merge(dst, src)
}
func (m *PingRes) XXX_Size() int {
	return xxx_messageInfo_PingRes.Size(m)
}
func (m *PingRes) XXX_DiscardUnknown() {
	xxx_messageInfo_PingRes.DiscardUnknown(m)
}

var xxx_messageInfo_PingRes proto.InternalMessageInfo

func (m *PingRes) GetEcho() string {
	if m != nil {
		return m.Echo
	}
	return ""
}

func init() {
	proto.RegisterType((*ListFilesystemReq)(nil), "ListFilesystemReq")
	proto.RegisterType((*ListFilesystemRes)(nil), "ListFilesystemRes")
	proto.RegisterType((*Filesystem)(nil), "Filesystem")
	proto.RegisterType((*ListFilesystemVersionsReq)(nil), "ListFilesystemVersionsReq")
	proto.RegisterType((*ListFilesystemVersionsRes)(nil), "ListFilesystemVersionsRes")
	proto.RegisterType((*FilesystemVersion)(nil), "FilesystemVersion")
	proto.RegisterType((*SendReq)(nil), "SendReq")
	proto.RegisterType((*ReplicationConfig)(nil), "ReplicationConfig")
	proto.RegisterType((*ReplicationConfigProtection)(nil), "ReplicationConfigProtection")
	proto.RegisterType((*Property)(nil), "Property")
	proto.RegisterType((*SendRes)(nil), "SendRes")
	proto.RegisterType((*SendCompletedReq)(nil), "SendCompletedReq")
	proto.RegisterType((*SendCompletedRes)(nil), "SendCompletedRes")
	proto.RegisterType((*ReceiveReq)(nil), "ReceiveReq")
	proto.RegisterType((*ReceiveRes)(nil), "ReceiveRes")
	proto.RegisterType((*DestroySnapshotsReq)(nil), "DestroySnapshotsReq")
	proto.RegisterType((*DestroySnapshotRes)(nil), "DestroySnapshotRes")
	proto.RegisterType((*DestroySnapshotsRes)(nil), "DestroySnapshotsRes")
	proto.RegisterType((*ReplicationCursorReq)(nil), "ReplicationCursorReq")
	proto.RegisterType((*ReplicationCursorRes)(nil), "ReplicationCursorRes")
	proto.RegisterType((*PingReq)(nil), "PingReq")
	proto.RegisterType((*PingRes)(nil), "PingRes")
	proto.RegisterEnum("Tri", Tri_name, Tri_value)
	proto.RegisterEnum("ReplicationGuaranteeKind", ReplicationGuaranteeKind_name, ReplicationGuaranteeKind_value)
	proto.RegisterEnum("FilesystemVersion_VersionType", FilesystemVersion_VersionType_name, FilesystemVersion_VersionType_value)
}

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

// ReplicationClient is the client API for Replication service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReplicationClient interface {
	Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingRes, error)
	ListFilesystems(ctx context.Context, in *ListFilesystemReq, opts ...grpc.CallOption) (*ListFilesystemRes, error)
	ListFilesystemVersions(ctx context.Context, in *ListFilesystemVersionsReq, opts ...grpc.CallOption) (*ListFilesystemVersionsRes, error)
	DestroySnapshots(ctx context.Context, in *DestroySnapshotsReq, opts ...grpc.CallOption) (*DestroySnapshotsRes, error)
	ReplicationCursor(ctx context.Context, in *ReplicationCursorReq, opts ...grpc.CallOption) (*ReplicationCursorRes, error)
	SendCompleted(ctx context.Context, in *SendCompletedReq, opts ...grpc.CallOption) (*SendCompletedRes, error)
}

type replicationClient struct {
	cc *grpc.ClientConn
}

func NewReplicationClient(cc *grpc.ClientConn) ReplicationClient {
	return &replicationClient{cc}
}

func (c *replicationClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingRes, error) {
	out := new(PingRes)
	err := c.cc.Invoke(ctx, "/Replication/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationClient) ListFilesystems(ctx context.Context, in *ListFilesystemReq, opts ...grpc.CallOption) (*ListFilesystemRes, error) {
	out := new(ListFilesystemRes)
	err := c.cc.Invoke(ctx, "/Replication/ListFilesystems", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationClient) ListFilesystemVersions(ctx context.Context, in *ListFilesystemVersionsReq, opts ...grpc.CallOption) (*ListFilesystemVersionsRes, error) {
	out := new(ListFilesystemVersionsRes)
	err := c.cc.Invoke(ctx, "/Replication/ListFilesystemVersions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationClient) DestroySnapshots(ctx context.Context, in *DestroySnapshotsReq, opts ...grpc.CallOption) (*DestroySnapshotsRes, error) {
	out := new(DestroySnapshotsRes)
	err := c.cc.Invoke(ctx, "/Replication/DestroySnapshots", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationClient) ReplicationCursor(ctx context.Context, in *ReplicationCursorReq, opts ...grpc.CallOption) (*ReplicationCursorRes, error) {
	out := new(ReplicationCursorRes)
	err := c.cc.Invoke(ctx, "/Replication/ReplicationCursor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicationClient) SendCompleted(ctx context.Context, in *SendCompletedReq, opts ...grpc.CallOption) (*SendCompletedRes, error) {
	out := new(SendCompletedRes)
	err := c.cc.Invoke(ctx, "/Replication/SendCompleted", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplicationServer is the server API for Replication service.
type ReplicationServer interface {
	Ping(context.Context, *PingReq) (*PingRes, error)
	ListFilesystems(context.Context, *ListFilesystemReq) (*ListFilesystemRes, error)
	ListFilesystemVersions(context.Context, *ListFilesystemVersionsReq) (*ListFilesystemVersionsRes, error)
	DestroySnapshots(context.Context, *DestroySnapshotsReq) (*DestroySnapshotsRes, error)
	ReplicationCursor(context.Context, *ReplicationCursorReq) (*ReplicationCursorRes, error)
	SendCompleted(context.Context, *SendCompletedReq) (*SendCompletedRes, error)
}

func RegisterReplicationServer(s *grpc.Server, srv ReplicationServer) {
	s.RegisterService(&_Replication_serviceDesc, srv)
}

func _Replication_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).Ping(ctx, req.(*PingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replication_ListFilesystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFilesystemReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).ListFilesystems(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/ListFilesystems",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).ListFilesystems(ctx, req.(*ListFilesystemReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replication_ListFilesystemVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFilesystemVersionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).ListFilesystemVersions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/ListFilesystemVersions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).ListFilesystemVersions(ctx, req.(*ListFilesystemVersionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replication_DestroySnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DestroySnapshotsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).DestroySnapshots(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/DestroySnapshots",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).DestroySnapshots(ctx, req.(*DestroySnapshotsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replication_ReplicationCursor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicationCursorReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).ReplicationCursor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/ReplicationCursor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).ReplicationCursor(ctx, req.(*ReplicationCursorReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replication_SendCompleted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendCompletedReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicationServer).SendCompleted(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Replication/SendCompleted",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicationServer).SendCompleted(ctx, req.(*SendCompletedReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Replication_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Replication",
	HandlerType: (*ReplicationServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _Replication_Ping_Handler,
		},
		{
			MethodName: "ListFilesystems",
			Handler:    _Replication_ListFilesystems_Handler,
		},
		{
			MethodName: "ListFilesystemVersions",
			Handler:    _Replication_ListFilesystemVersions_Handler,
		},
		{
			MethodName: "DestroySnapshots",
			Handler:    _Replication_DestroySnapshots_Handler,
		},
		{
			MethodName: "ReplicationCursor",
			Handler:    _Replication_ReplicationCursor_Handler,
		},
		{
			MethodName: "SendCompleted",
			Handler:    _Replication_SendCompleted_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pdu.proto",
}

func init() { proto.RegisterFile("pdu.proto", fileDescriptor_pdu_616c27178643eca4) }

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