btrdb.pb.go

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

/*
Package grpcinterface is a generated protocol buffer package.

Version 4.2

It is generated from these files:
	btrdb.proto

It has these top-level messages:
	RawValuesParams
	RawValuesResponse
	AlignedWindowsParams
	AlignedWindowsResponse
	WindowsParams
	WindowsResponse
	StreamInfoParams
	StreamInfoResponse
	StreamDescriptor
	SetStreamAnnotationsParams
	SetStreamAnnotationsResponse
	CreateParams
	CreateResponse
	ListCollectionsParams
	ListCollectionsResponse
	LookupStreamsParams
	LookupStreamsResponse
	NearestParams
	NearestResponse
	ChangesParams
	ChangesResponse
	InsertParams
	InsertResponse
	DeleteParams
	DeleteResponse
	InfoParams
	InfoResponse
	ProxyInfo
	FaultInjectParams
	FaultInjectResponse
	FlushParams
	FlushResponse
	ObliterateParams
	ObliterateResponse
	RawPoint
	StatPoint
	ChangedRange
	Status
	Mash
	Member
	KeyOptValue
	OptValue
	KeyValue
*/
package grpcinterface

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 RawValuesParams struct {
	Uuid         []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Start        int64  `protobuf:"fixed64,2,opt,name=start" json:"start,omitempty"`
	End          int64  `protobuf:"fixed64,3,opt,name=end" json:"end,omitempty"`
	VersionMajor uint64 `protobuf:"varint,4,opt,name=versionMajor" json:"versionMajor,omitempty"`
}

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

func (m *RawValuesParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *RawValuesParams) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *RawValuesParams) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

func (m *RawValuesParams) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

type RawValuesResponse struct {
	Stat         *Status     `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64      `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64      `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Values       []*RawPoint `protobuf:"bytes,4,rep,name=values" json:"values,omitempty"`
}

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

func (m *RawValuesResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *RawValuesResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *RawValuesResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *RawValuesResponse) GetValues() []*RawPoint {
	if m != nil {
		return m.Values
	}
	return nil
}

type AlignedWindowsParams struct {
	Uuid         []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Start        int64  `protobuf:"fixed64,2,opt,name=start" json:"start,omitempty"`
	End          int64  `protobuf:"fixed64,3,opt,name=end" json:"end,omitempty"`
	VersionMajor uint64 `protobuf:"varint,4,opt,name=versionMajor" json:"versionMajor,omitempty"`
	PointWidth   uint32 `protobuf:"varint,5,opt,name=pointWidth" json:"pointWidth,omitempty"`
}

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

func (m *AlignedWindowsParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *AlignedWindowsParams) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *AlignedWindowsParams) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

func (m *AlignedWindowsParams) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *AlignedWindowsParams) GetPointWidth() uint32 {
	if m != nil {
		return m.PointWidth
	}
	return 0
}

type AlignedWindowsResponse struct {
	Stat         *Status      `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64       `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64       `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Values       []*StatPoint `protobuf:"bytes,4,rep,name=values" json:"values,omitempty"`
}

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

func (m *AlignedWindowsResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *AlignedWindowsResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *AlignedWindowsResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *AlignedWindowsResponse) GetValues() []*StatPoint {
	if m != nil {
		return m.Values
	}
	return nil
}

type WindowsParams struct {
	Uuid         []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Start        int64  `protobuf:"fixed64,2,opt,name=start" json:"start,omitempty"`
	End          int64  `protobuf:"fixed64,3,opt,name=end" json:"end,omitempty"`
	VersionMajor uint64 `protobuf:"varint,4,opt,name=versionMajor" json:"versionMajor,omitempty"`
	Width        uint64 `protobuf:"varint,5,opt,name=width" json:"width,omitempty"`
	Depth        uint32 `protobuf:"varint,6,opt,name=depth" json:"depth,omitempty"`
}

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

func (m *WindowsParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *WindowsParams) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *WindowsParams) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

func (m *WindowsParams) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *WindowsParams) GetWidth() uint64 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *WindowsParams) GetDepth() uint32 {
	if m != nil {
		return m.Depth
	}
	return 0
}

type WindowsResponse struct {
	Stat         *Status      `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64       `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64       `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Values       []*StatPoint `protobuf:"bytes,4,rep,name=values" json:"values,omitempty"`
}

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

func (m *WindowsResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *WindowsResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *WindowsResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *WindowsResponse) GetValues() []*StatPoint {
	if m != nil {
		return m.Values
	}
	return nil
}

type StreamInfoParams struct {
	Uuid           []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	OmitVersion    bool   `protobuf:"varint,2,opt,name=omitVersion" json:"omitVersion,omitempty"`
	OmitDescriptor bool   `protobuf:"varint,3,opt,name=omitDescriptor" json:"omitDescriptor,omitempty"`
}

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

func (m *StreamInfoParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *StreamInfoParams) GetOmitVersion() bool {
	if m != nil {
		return m.OmitVersion
	}
	return false
}

func (m *StreamInfoParams) GetOmitDescriptor() bool {
	if m != nil {
		return m.OmitDescriptor
	}
	return false
}

type StreamInfoResponse struct {
	Stat         *Status           `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64            `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64            `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Descriptor_  *StreamDescriptor `protobuf:"bytes,4,opt,name=descriptor" json:"descriptor,omitempty"`
}

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

func (m *StreamInfoResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *StreamInfoResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *StreamInfoResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *StreamInfoResponse) GetDescriptor_() *StreamDescriptor {
	if m != nil {
		return m.Descriptor_
	}
	return nil
}

type StreamDescriptor struct {
	Uuid              []byte      `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Collection        string      `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
	Tags              []*KeyValue `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
	Annotations       []*KeyValue `protobuf:"bytes,4,rep,name=annotations" json:"annotations,omitempty"`
	AnnotationVersion uint64      `protobuf:"varint,5,opt,name=annotationVersion" json:"annotationVersion,omitempty"`
}

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

func (m *StreamDescriptor) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *StreamDescriptor) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *StreamDescriptor) GetTags() []*KeyValue {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *StreamDescriptor) GetAnnotations() []*KeyValue {
	if m != nil {
		return m.Annotations
	}
	return nil
}

func (m *StreamDescriptor) GetAnnotationVersion() uint64 {
	if m != nil {
		return m.AnnotationVersion
	}
	return 0
}

type SetStreamAnnotationsParams struct {
	Uuid                      []byte         `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	ExpectedAnnotationVersion uint64         `protobuf:"varint,2,opt,name=expectedAnnotationVersion" json:"expectedAnnotationVersion,omitempty"`
	Annotations               []*KeyOptValue `protobuf:"bytes,3,rep,name=annotations" json:"annotations,omitempty"`
}

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

func (m *SetStreamAnnotationsParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *SetStreamAnnotationsParams) GetExpectedAnnotationVersion() uint64 {
	if m != nil {
		return m.ExpectedAnnotationVersion
	}
	return 0
}

func (m *SetStreamAnnotationsParams) GetAnnotations() []*KeyOptValue {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type SetStreamAnnotationsResponse struct {
	Stat *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
}

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

func (m *SetStreamAnnotationsResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

type CreateParams struct {
	Uuid        []byte      `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Collection  string      `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
	Tags        []*KeyValue `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
	Annotations []*KeyValue `protobuf:"bytes,4,rep,name=annotations" json:"annotations,omitempty"`
}

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

func (m *CreateParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *CreateParams) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *CreateParams) GetTags() []*KeyValue {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *CreateParams) GetAnnotations() []*KeyValue {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type CreateResponse struct {
	Stat *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
}

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

func (m *CreateResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

type ListCollectionsParams struct {
	Prefix    string `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"`
	StartWith string `protobuf:"bytes,2,opt,name=startWith" json:"startWith,omitempty"`
	Limit     uint64 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
}

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

func (m *ListCollectionsParams) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *ListCollectionsParams) GetStartWith() string {
	if m != nil {
		return m.StartWith
	}
	return ""
}

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

type ListCollectionsResponse struct {
	Stat        *Status  `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	Collections []string `protobuf:"bytes,2,rep,name=collections" json:"collections,omitempty"`
}

func (m *ListCollectionsResponse) Reset()                    { *m = ListCollectionsResponse{} }
func (m *ListCollectionsResponse) String() string            { return proto.CompactTextString(m) }
func (*ListCollectionsResponse) ProtoMessage()               {}
func (*ListCollectionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }

func (m *ListCollectionsResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *ListCollectionsResponse) GetCollections() []string {
	if m != nil {
		return m.Collections
	}
	return nil
}

type LookupStreamsParams struct {
	Collection         string         `protobuf:"bytes,1,opt,name=collection" json:"collection,omitempty"`
	IsCollectionPrefix bool           `protobuf:"varint,2,opt,name=isCollectionPrefix" json:"isCollectionPrefix,omitempty"`
	Tags               []*KeyOptValue `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
	Annotations        []*KeyOptValue `protobuf:"bytes,4,rep,name=annotations" json:"annotations,omitempty"`
}

func (m *LookupStreamsParams) Reset()                    { *m = LookupStreamsParams{} }
func (m *LookupStreamsParams) String() string            { return proto.CompactTextString(m) }
func (*LookupStreamsParams) ProtoMessage()               {}
func (*LookupStreamsParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }

func (m *LookupStreamsParams) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *LookupStreamsParams) GetIsCollectionPrefix() bool {
	if m != nil {
		return m.IsCollectionPrefix
	}
	return false
}

func (m *LookupStreamsParams) GetTags() []*KeyOptValue {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *LookupStreamsParams) GetAnnotations() []*KeyOptValue {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type LookupStreamsResponse struct {
	Stat    *Status             `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	Results []*StreamDescriptor `protobuf:"bytes,2,rep,name=results" json:"results,omitempty"`
}

func (m *LookupStreamsResponse) Reset()                    { *m = LookupStreamsResponse{} }
func (m *LookupStreamsResponse) String() string            { return proto.CompactTextString(m) }
func (*LookupStreamsResponse) ProtoMessage()               {}
func (*LookupStreamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }

func (m *LookupStreamsResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

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

type NearestParams struct {
	Uuid         []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Time         int64  `protobuf:"fixed64,2,opt,name=time" json:"time,omitempty"`
	VersionMajor uint64 `protobuf:"varint,3,opt,name=versionMajor" json:"versionMajor,omitempty"`
	Backward     bool   `protobuf:"varint,4,opt,name=backward" json:"backward,omitempty"`
}

func (m *NearestParams) Reset()                    { *m = NearestParams{} }
func (m *NearestParams) String() string            { return proto.CompactTextString(m) }
func (*NearestParams) ProtoMessage()               {}
func (*NearestParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }

func (m *NearestParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *NearestParams) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *NearestParams) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *NearestParams) GetBackward() bool {
	if m != nil {
		return m.Backward
	}
	return false
}

type NearestResponse struct {
	Stat         *Status   `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64    `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64    `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Value        *RawPoint `protobuf:"bytes,4,opt,name=value" json:"value,omitempty"`
}

func (m *NearestResponse) Reset()                    { *m = NearestResponse{} }
func (m *NearestResponse) String() string            { return proto.CompactTextString(m) }
func (*NearestResponse) ProtoMessage()               {}
func (*NearestResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }

func (m *NearestResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *NearestResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *NearestResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *NearestResponse) GetValue() *RawPoint {
	if m != nil {
		return m.Value
	}
	return nil
}

type ChangesParams struct {
	Uuid       []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	FromMajor  uint64 `protobuf:"varint,2,opt,name=fromMajor" json:"fromMajor,omitempty"`
	ToMajor    uint64 `protobuf:"varint,3,opt,name=toMajor" json:"toMajor,omitempty"`
	Resolution uint32 `protobuf:"varint,4,opt,name=resolution" json:"resolution,omitempty"`
}

func (m *ChangesParams) Reset()                    { *m = ChangesParams{} }
func (m *ChangesParams) String() string            { return proto.CompactTextString(m) }
func (*ChangesParams) ProtoMessage()               {}
func (*ChangesParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }

func (m *ChangesParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *ChangesParams) GetFromMajor() uint64 {
	if m != nil {
		return m.FromMajor
	}
	return 0
}

func (m *ChangesParams) GetToMajor() uint64 {
	if m != nil {
		return m.ToMajor
	}
	return 0
}

func (m *ChangesParams) GetResolution() uint32 {
	if m != nil {
		return m.Resolution
	}
	return 0
}

type ChangesResponse struct {
	Stat         *Status         `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64          `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64          `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
	Ranges       []*ChangedRange `protobuf:"bytes,4,rep,name=ranges" json:"ranges,omitempty"`
}

func (m *ChangesResponse) Reset()                    { *m = ChangesResponse{} }
func (m *ChangesResponse) String() string            { return proto.CompactTextString(m) }
func (*ChangesResponse) ProtoMessage()               {}
func (*ChangesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }

func (m *ChangesResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *ChangesResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *ChangesResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

func (m *ChangesResponse) GetRanges() []*ChangedRange {
	if m != nil {
		return m.Ranges
	}
	return nil
}

type InsertParams struct {
	Uuid   []byte      `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Sync   bool        `protobuf:"varint,2,opt,name=sync" json:"sync,omitempty"`
	Values []*RawPoint `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
}

func (m *InsertParams) Reset()                    { *m = InsertParams{} }
func (m *InsertParams) String() string            { return proto.CompactTextString(m) }
func (*InsertParams) ProtoMessage()               {}
func (*InsertParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }

func (m *InsertParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *InsertParams) GetSync() bool {
	if m != nil {
		return m.Sync
	}
	return false
}

func (m *InsertParams) GetValues() []*RawPoint {
	if m != nil {
		return m.Values
	}
	return nil
}

type InsertResponse struct {
	Stat         *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64  `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64  `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
}

func (m *InsertResponse) Reset()                    { *m = InsertResponse{} }
func (m *InsertResponse) String() string            { return proto.CompactTextString(m) }
func (*InsertResponse) ProtoMessage()               {}
func (*InsertResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }

func (m *InsertResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *InsertResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *InsertResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

type DeleteParams struct {
	Uuid  []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Start int64  `protobuf:"fixed64,2,opt,name=start" json:"start,omitempty"`
	End   int64  `protobuf:"fixed64,3,opt,name=end" json:"end,omitempty"`
}

func (m *DeleteParams) Reset()                    { *m = DeleteParams{} }
func (m *DeleteParams) String() string            { return proto.CompactTextString(m) }
func (*DeleteParams) ProtoMessage()               {}
func (*DeleteParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }

func (m *DeleteParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

func (m *DeleteParams) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *DeleteParams) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

type DeleteResponse struct {
	Stat         *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64  `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64  `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
}

func (m *DeleteResponse) Reset()                    { *m = DeleteResponse{} }
func (m *DeleteResponse) String() string            { return proto.CompactTextString(m) }
func (*DeleteResponse) ProtoMessage()               {}
func (*DeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }

func (m *DeleteResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *DeleteResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *DeleteResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

type InfoParams struct {
}

func (m *InfoParams) Reset()                    { *m = InfoParams{} }
func (m *InfoParams) String() string            { return proto.CompactTextString(m) }
func (*InfoParams) ProtoMessage()               {}
func (*InfoParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }

type InfoResponse struct {
	Stat         *Status    `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	Mash         *Mash      `protobuf:"bytes,2,opt,name=mash" json:"mash,omitempty"`
	MajorVersion uint32     `protobuf:"varint,3,opt,name=majorVersion" json:"majorVersion,omitempty"`
	MinorVersion uint32     `protobuf:"varint,4,opt,name=minorVersion" json:"minorVersion,omitempty"`
	Build        string     `protobuf:"bytes,5,opt,name=build" json:"build,omitempty"`
	Proxy        *ProxyInfo `protobuf:"bytes,6,opt,name=proxy" json:"proxy,omitempty"`
}

func (m *InfoResponse) Reset()                    { *m = InfoResponse{} }
func (m *InfoResponse) String() string            { return proto.CompactTextString(m) }
func (*InfoResponse) ProtoMessage()               {}
func (*InfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }

func (m *InfoResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *InfoResponse) GetMash() *Mash {
	if m != nil {
		return m.Mash
	}
	return nil
}

func (m *InfoResponse) GetMajorVersion() uint32 {
	if m != nil {
		return m.MajorVersion
	}
	return 0
}

func (m *InfoResponse) GetMinorVersion() uint32 {
	if m != nil {
		return m.MinorVersion
	}
	return 0
}

func (m *InfoResponse) GetBuild() string {
	if m != nil {
		return m.Build
	}
	return ""
}

func (m *InfoResponse) GetProxy() *ProxyInfo {
	if m != nil {
		return m.Proxy
	}
	return nil
}

type ProxyInfo struct {
	ProxyEndpoints []string `protobuf:"bytes,1,rep,name=proxyEndpoints" json:"proxyEndpoints,omitempty"`
}

func (m *ProxyInfo) Reset()                    { *m = ProxyInfo{} }
func (m *ProxyInfo) String() string            { return proto.CompactTextString(m) }
func (*ProxyInfo) ProtoMessage()               {}
func (*ProxyInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }

func (m *ProxyInfo) GetProxyEndpoints() []string {
	if m != nil {
		return m.ProxyEndpoints
	}
	return nil
}

type FaultInjectParams struct {
	Type   uint64 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
	Params []byte `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
}

func (m *FaultInjectParams) Reset()                    { *m = FaultInjectParams{} }
func (m *FaultInjectParams) String() string            { return proto.CompactTextString(m) }
func (*FaultInjectParams) ProtoMessage()               {}
func (*FaultInjectParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }

func (m *FaultInjectParams) GetType() uint64 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *FaultInjectParams) GetParams() []byte {
	if m != nil {
		return m.Params
	}
	return nil
}

type FaultInjectResponse struct {
	Stat *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	Rv   []byte  `protobuf:"bytes,2,opt,name=rv,proto3" json:"rv,omitempty"`
}

func (m *FaultInjectResponse) Reset()                    { *m = FaultInjectResponse{} }
func (m *FaultInjectResponse) String() string            { return proto.CompactTextString(m) }
func (*FaultInjectResponse) ProtoMessage()               {}
func (*FaultInjectResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }

func (m *FaultInjectResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *FaultInjectResponse) GetRv() []byte {
	if m != nil {
		return m.Rv
	}
	return nil
}

type FlushParams struct {
	Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
}

func (m *FlushParams) Reset()                    { *m = FlushParams{} }
func (m *FlushParams) String() string            { return proto.CompactTextString(m) }
func (*FlushParams) ProtoMessage()               {}
func (*FlushParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }

func (m *FlushParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

type FlushResponse struct {
	Stat         *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	VersionMajor uint64  `protobuf:"varint,2,opt,name=versionMajor" json:"versionMajor,omitempty"`
	VersionMinor uint64  `protobuf:"varint,3,opt,name=versionMinor" json:"versionMinor,omitempty"`
}

func (m *FlushResponse) Reset()                    { *m = FlushResponse{} }
func (m *FlushResponse) String() string            { return proto.CompactTextString(m) }
func (*FlushResponse) ProtoMessage()               {}
func (*FlushResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }

func (m *FlushResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

func (m *FlushResponse) GetVersionMajor() uint64 {
	if m != nil {
		return m.VersionMajor
	}
	return 0
}

func (m *FlushResponse) GetVersionMinor() uint64 {
	if m != nil {
		return m.VersionMinor
	}
	return 0
}

type ObliterateParams struct {
	Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
}

func (m *ObliterateParams) Reset()                    { *m = ObliterateParams{} }
func (m *ObliterateParams) String() string            { return proto.CompactTextString(m) }
func (*ObliterateParams) ProtoMessage()               {}
func (*ObliterateParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }

func (m *ObliterateParams) GetUuid() []byte {
	if m != nil {
		return m.Uuid
	}
	return nil
}

type ObliterateResponse struct {
	Stat *Status `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
}

func (m *ObliterateResponse) Reset()                    { *m = ObliterateResponse{} }
func (m *ObliterateResponse) String() string            { return proto.CompactTextString(m) }
func (*ObliterateResponse) ProtoMessage()               {}
func (*ObliterateResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }

func (m *ObliterateResponse) GetStat() *Status {
	if m != nil {
		return m.Stat
	}
	return nil
}

type RawPoint struct {
	Time  int64   `protobuf:"fixed64,1,opt,name=time" json:"time,omitempty"`
	Value float64 `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"`
}

func (m *RawPoint) Reset()                    { *m = RawPoint{} }
func (m *RawPoint) String() string            { return proto.CompactTextString(m) }
func (*RawPoint) ProtoMessage()               {}
func (*RawPoint) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }

func (m *RawPoint) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *RawPoint) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type StatPoint struct {
	Time  int64   `protobuf:"fixed64,1,opt,name=time" json:"time,omitempty"`
	Min   float64 `protobuf:"fixed64,2,opt,name=min" json:"min,omitempty"`
	Mean  float64 `protobuf:"fixed64,3,opt,name=mean" json:"mean,omitempty"`
	Max   float64 `protobuf:"fixed64,4,opt,name=max" json:"max,omitempty"`
	Count uint64  `protobuf:"fixed64,5,opt,name=count" json:"count,omitempty"`
}

func (m *StatPoint) Reset()                    { *m = StatPoint{} }
func (m *StatPoint) String() string            { return proto.CompactTextString(m) }
func (*StatPoint) ProtoMessage()               {}
func (*StatPoint) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }

func (m *StatPoint) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *StatPoint) GetMin() float64 {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *StatPoint) GetMean() float64 {
	if m != nil {
		return m.Mean
	}
	return 0
}

func (m *StatPoint) GetMax() float64 {
	if m != nil {
		return m.Max
	}
	return 0
}

func (m *StatPoint) GetCount() uint64 {
	if m != nil {
		return m.Count
	}
	return 0
}

type ChangedRange struct {
	Start int64 `protobuf:"fixed64,1,opt,name=start" json:"start,omitempty"`
	End   int64 `protobuf:"fixed64,2,opt,name=end" json:"end,omitempty"`
}

func (m *ChangedRange) Reset()                    { *m = ChangedRange{} }
func (m *ChangedRange) String() string            { return proto.CompactTextString(m) }
func (*ChangedRange) ProtoMessage()               {}
func (*ChangedRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }

func (m *ChangedRange) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *ChangedRange) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

type Status struct {
	Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Msg  string `protobuf:"bytes,2,opt,name=msg" json:"msg,omitempty"`
	Mash *Mash  `protobuf:"bytes,3,opt,name=mash" json:"mash,omitempty"`
}

func (m *Status) Reset()                    { *m = Status{} }
func (m *Status) String() string            { return proto.CompactTextString(m) }
func (*Status) ProtoMessage()               {}
func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }

func (m *Status) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *Status) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *Status) GetMash() *Mash {
	if m != nil {
		return m.Mash
	}
	return nil
}

type Mash struct {
	Revision       int64     `protobuf:"varint,1,opt,name=revision" json:"revision,omitempty"`
	Leader         string    `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"`
	LeaderRevision int64     `protobuf:"varint,3,opt,name=leaderRevision" json:"leaderRevision,omitempty"`
	TotalWeight    int64     `protobuf:"varint,4,opt,name=totalWeight" json:"totalWeight,omitempty"`
	Healthy        bool      `protobuf:"varint,5,opt,name=healthy" json:"healthy,omitempty"`
	Unmapped       float64   `protobuf:"fixed64,6,opt,name=unmapped" json:"unmapped,omitempty"`
	Members        []*Member `protobuf:"bytes,7,rep,name=members" json:"members,omitempty"`
}

func (m *Mash) Reset()                    { *m = Mash{} }
func (m *Mash) String() string            { return proto.CompactTextString(m) }
func (*Mash) ProtoMessage()               {}
func (*Mash) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }

func (m *Mash) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *Mash) GetLeader() string {
	if m != nil {
		return m.Leader
	}
	return ""
}

func (m *Mash) GetLeaderRevision() int64 {
	if m != nil {
		return m.LeaderRevision
	}
	return 0
}

func (m *Mash) GetTotalWeight() int64 {
	if m != nil {
		return m.TotalWeight
	}
	return 0
}

func (m *Mash) GetHealthy() bool {
	if m != nil {
		return m.Healthy
	}
	return false
}

func (m *Mash) GetUnmapped() float64 {
	if m != nil {
		return m.Unmapped
	}
	return 0
}

func (m *Mash) GetMembers() []*Member {
	if m != nil {
		return m.Members
	}
	return nil
}

type Member struct {
	Hash           uint32  `protobuf:"varint,1,opt,name=hash" json:"hash,omitempty"`
	Nodename       string  `protobuf:"bytes,2,opt,name=nodename" json:"nodename,omitempty"`
	Up             bool    `protobuf:"varint,3,opt,name=up" json:"up,omitempty"`
	In             bool    `protobuf:"varint,4,opt,name=in" json:"in,omitempty"`
	Enabled        bool    `protobuf:"varint,5,opt,name=enabled" json:"enabled,omitempty"`
	Start          int64   `protobuf:"varint,6,opt,name=start" json:"start,omitempty"`
	End            int64   `protobuf:"varint,7,opt,name=end" json:"end,omitempty"`
	Weight         int64   `protobuf:"varint,8,opt,name=weight" json:"weight,omitempty"`
	ReadPreference float64 `protobuf:"fixed64,9,opt,name=readPreference" json:"readPreference,omitempty"`
	HttpEndpoints  string  `protobuf:"bytes,10,opt,name=httpEndpoints" json:"httpEndpoints,omitempty"`
	GrpcEndpoints  string  `protobuf:"bytes,11,opt,name=grpcEndpoints" json:"grpcEndpoints,omitempty"`
}

func (m *Member) Reset()                    { *m = Member{} }
func (m *Member) String() string            { return proto.CompactTextString(m) }
func (*Member) ProtoMessage()               {}
func (*Member) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }

func (m *Member) GetHash() uint32 {
	if m != nil {
		return m.Hash
	}
	return 0
}

func (m *Member) GetNodename() string {
	if m != nil {
		return m.Nodename
	}
	return ""
}

func (m *Member) GetUp() bool {
	if m != nil {
		return m.Up
	}
	return false
}

func (m *Member) GetIn() bool {
	if m != nil {
		return m.In
	}
	return false
}

func (m *Member) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *Member) GetStart() int64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *Member) GetEnd() int64 {
	if m != nil {
		return m.End
	}
	return 0
}

func (m *Member) GetWeight() int64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *Member) GetReadPreference() float64 {
	if m != nil {
		return m.ReadPreference
	}
	return 0
}

func (m *Member) GetHttpEndpoints() string {
	if m != nil {
		return m.HttpEndpoints
	}
	return ""
}

func (m *Member) GetGrpcEndpoints() string {
	if m != nil {
		return m.GrpcEndpoints
	}
	return ""
}

type KeyOptValue struct {
	Key string    `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Val *OptValue `protobuf:"bytes,2,opt,name=val" json:"val,omitempty"`
}

func (m *KeyOptValue) Reset()                    { *m = KeyOptValue{} }
func (m *KeyOptValue) String() string            { return proto.CompactTextString(m) }
func (*KeyOptValue) ProtoMessage()               {}
func (*KeyOptValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }

func (m *KeyOptValue) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KeyOptValue) GetVal() *OptValue {
	if m != nil {
		return m.Val
	}
	return nil
}

type OptValue struct {
	Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *OptValue) Reset()                    { *m = OptValue{} }
func (m *OptValue) String() string            { return proto.CompactTextString(m) }
func (*OptValue) ProtoMessage()               {}
func (*OptValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }

func (m *OptValue) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type KeyValue struct {
	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *KeyValue) Reset()                    { *m = KeyValue{} }
func (m *KeyValue) String() string            { return proto.CompactTextString(m) }
func (*KeyValue) ProtoMessage()               {}
func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }

func (m *KeyValue) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KeyValue) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func init() {
	proto.RegisterType((*RawValuesParams)(nil), "grpcinterface.RawValuesParams")
	proto.RegisterType((*RawValuesResponse)(nil), "grpcinterface.RawValuesResponse")
	proto.RegisterType((*AlignedWindowsParams)(nil), "grpcinterface.AlignedWindowsParams")
	proto.RegisterType((*AlignedWindowsResponse)(nil), "grpcinterface.AlignedWindowsResponse")
	proto.RegisterType((*WindowsParams)(nil), "grpcinterface.WindowsParams")
	proto.RegisterType((*WindowsResponse)(nil), "grpcinterface.WindowsResponse")
	proto.RegisterType((*StreamInfoParams)(nil), "grpcinterface.StreamInfoParams")
	proto.RegisterType((*StreamInfoResponse)(nil), "grpcinterface.StreamInfoResponse")
	proto.RegisterType((*StreamDescriptor)(nil), "grpcinterface.StreamDescriptor")
	proto.RegisterType((*SetStreamAnnotationsParams)(nil), "grpcinterface.SetStreamAnnotationsParams")
	proto.RegisterType((*SetStreamAnnotationsResponse)(nil), "grpcinterface.SetStreamAnnotationsResponse")
	proto.RegisterType((*CreateParams)(nil), "grpcinterface.CreateParams")
	proto.RegisterType((*CreateResponse)(nil), "grpcinterface.CreateResponse")
	proto.RegisterType((*ListCollectionsParams)(nil), "grpcinterface.ListCollectionsParams")
	proto.RegisterType((*ListCollectionsResponse)(nil), "grpcinterface.ListCollectionsResponse")
	proto.RegisterType((*LookupStreamsParams)(nil), "grpcinterface.LookupStreamsParams")
	proto.RegisterType((*LookupStreamsResponse)(nil), "grpcinterface.LookupStreamsResponse")
	proto.RegisterType((*NearestParams)(nil), "grpcinterface.NearestParams")
	proto.RegisterType((*NearestResponse)(nil), "grpcinterface.NearestResponse")
	proto.RegisterType((*ChangesParams)(nil), "grpcinterface.ChangesParams")
	proto.RegisterType((*ChangesResponse)(nil), "grpcinterface.ChangesResponse")
	proto.RegisterType((*InsertParams)(nil), "grpcinterface.InsertParams")
	proto.RegisterType((*InsertResponse)(nil), "grpcinterface.InsertResponse")
	proto.RegisterType((*DeleteParams)(nil), "grpcinterface.DeleteParams")
	proto.RegisterType((*DeleteResponse)(nil), "grpcinterface.DeleteResponse")
	proto.RegisterType((*InfoParams)(nil), "grpcinterface.InfoParams")
	proto.RegisterType((*InfoResponse)(nil), "grpcinterface.InfoResponse")
	proto.RegisterType((*ProxyInfo)(nil), "grpcinterface.ProxyInfo")
	proto.RegisterType((*FaultInjectParams)(nil), "grpcinterface.FaultInjectParams")
	proto.RegisterType((*FaultInjectResponse)(nil), "grpcinterface.FaultInjectResponse")
	proto.RegisterType((*FlushParams)(nil), "grpcinterface.FlushParams")
	proto.RegisterType((*FlushResponse)(nil), "grpcinterface.FlushResponse")
	proto.RegisterType((*ObliterateParams)(nil), "grpcinterface.ObliterateParams")
	proto.RegisterType((*ObliterateResponse)(nil), "grpcinterface.ObliterateResponse")
	proto.RegisterType((*RawPoint)(nil), "grpcinterface.RawPoint")
	proto.RegisterType((*StatPoint)(nil), "grpcinterface.StatPoint")
	proto.RegisterType((*ChangedRange)(nil), "grpcinterface.ChangedRange")
	proto.RegisterType((*Status)(nil), "grpcinterface.Status")
	proto.RegisterType((*Mash)(nil), "grpcinterface.Mash")
	proto.RegisterType((*Member)(nil), "grpcinterface.Member")
	proto.RegisterType((*KeyOptValue)(nil), "grpcinterface.KeyOptValue")
	proto.RegisterType((*OptValue)(nil), "grpcinterface.OptValue")
	proto.RegisterType((*KeyValue)(nil), "grpcinterface.KeyValue")
}

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

// Client API for BTrDB service

type BTrDBClient interface {
	RawValues(ctx context.Context, in *RawValuesParams, opts ...grpc.CallOption) (BTrDB_RawValuesClient, error)
	AlignedWindows(ctx context.Context, in *AlignedWindowsParams, opts ...grpc.CallOption) (BTrDB_AlignedWindowsClient, error)
	Windows(ctx context.Context, in *WindowsParams, opts ...grpc.CallOption) (BTrDB_WindowsClient, error)
	StreamInfo(ctx context.Context, in *StreamInfoParams, opts ...grpc.CallOption) (*StreamInfoResponse, error)
	SetStreamAnnotations(ctx context.Context, in *SetStreamAnnotationsParams, opts ...grpc.CallOption) (*SetStreamAnnotationsResponse, error)
	Create(ctx context.Context, in *CreateParams, opts ...grpc.CallOption) (*CreateResponse, error)
	ListCollections(ctx context.Context, in *ListCollectionsParams, opts ...grpc.CallOption) (*ListCollectionsResponse, error)
	LookupStreams(ctx context.Context, in *LookupStreamsParams, opts ...grpc.CallOption) (BTrDB_LookupStreamsClient, error)
	Nearest(ctx context.Context, in *NearestParams, opts ...grpc.CallOption) (*NearestResponse, error)
	Changes(ctx context.Context, in *ChangesParams, opts ...grpc.CallOption) (BTrDB_ChangesClient, error)
	Insert(ctx context.Context, in *InsertParams, opts ...grpc.CallOption) (*InsertResponse, error)
	Delete(ctx context.Context, in *DeleteParams, opts ...grpc.CallOption) (*DeleteResponse, error)
	Info(ctx context.Context, in *InfoParams, opts ...grpc.CallOption) (*InfoResponse, error)
	FaultInject(ctx context.Context, in *FaultInjectParams, opts ...grpc.CallOption) (*FaultInjectResponse, error)
	Flush(ctx context.Context, in *FlushParams, opts ...grpc.CallOption) (*FlushResponse, error)
	Obliterate(ctx context.Context, in *ObliterateParams, opts ...grpc.CallOption) (*ObliterateResponse, error)
}

type bTrDBClient struct {
	cc *grpc.ClientConn
}

func NewBTrDBClient(cc *grpc.ClientConn) BTrDBClient {
	return &bTrDBClient{cc}
}

func (c *bTrDBClient) RawValues(ctx context.Context, in *RawValuesParams, opts ...grpc.CallOption) (BTrDB_RawValuesClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_BTrDB_serviceDesc.Streams[0], c.cc, "/grpcinterface.BTrDB/RawValues", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBRawValuesClient{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 BTrDB_RawValuesClient interface {
	Recv() (*RawValuesResponse, error)
	grpc.ClientStream
}

type bTrDBRawValuesClient struct {
	grpc.ClientStream
}

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

func (c *bTrDBClient) AlignedWindows(ctx context.Context, in *AlignedWindowsParams, opts ...grpc.CallOption) (BTrDB_AlignedWindowsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_BTrDB_serviceDesc.Streams[1], c.cc, "/grpcinterface.BTrDB/AlignedWindows", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBAlignedWindowsClient{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 BTrDB_AlignedWindowsClient interface {
	Recv() (*AlignedWindowsResponse, error)
	grpc.ClientStream
}

type bTrDBAlignedWindowsClient struct {
	grpc.ClientStream
}

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

func (c *bTrDBClient) Windows(ctx context.Context, in *WindowsParams, opts ...grpc.CallOption) (BTrDB_WindowsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_BTrDB_serviceDesc.Streams[2], c.cc, "/grpcinterface.BTrDB/Windows", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBWindowsClient{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 BTrDB_WindowsClient interface {
	Recv() (*WindowsResponse, error)
	grpc.ClientStream
}

type bTrDBWindowsClient struct {
	grpc.ClientStream
}

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

func (c *bTrDBClient) StreamInfo(ctx context.Context, in *StreamInfoParams, opts ...grpc.CallOption) (*StreamInfoResponse, error) {
	out := new(StreamInfoResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/StreamInfo", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) SetStreamAnnotations(ctx context.Context, in *SetStreamAnnotationsParams, opts ...grpc.CallOption) (*SetStreamAnnotationsResponse, error) {
	out := new(SetStreamAnnotationsResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/SetStreamAnnotations", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Create(ctx context.Context, in *CreateParams, opts ...grpc.CallOption) (*CreateResponse, error) {
	out := new(CreateResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Create", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) ListCollections(ctx context.Context, in *ListCollectionsParams, opts ...grpc.CallOption) (*ListCollectionsResponse, error) {
	out := new(ListCollectionsResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/ListCollections", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) LookupStreams(ctx context.Context, in *LookupStreamsParams, opts ...grpc.CallOption) (BTrDB_LookupStreamsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_BTrDB_serviceDesc.Streams[3], c.cc, "/grpcinterface.BTrDB/LookupStreams", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBLookupStreamsClient{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 BTrDB_LookupStreamsClient interface {
	Recv() (*LookupStreamsResponse, error)
	grpc.ClientStream
}

type bTrDBLookupStreamsClient struct {
	grpc.ClientStream
}

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

func (c *bTrDBClient) Nearest(ctx context.Context, in *NearestParams, opts ...grpc.CallOption) (*NearestResponse, error) {
	out := new(NearestResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Nearest", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Changes(ctx context.Context, in *ChangesParams, opts ...grpc.CallOption) (BTrDB_ChangesClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_BTrDB_serviceDesc.Streams[4], c.cc, "/grpcinterface.BTrDB/Changes", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBChangesClient{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 BTrDB_ChangesClient interface {
	Recv() (*ChangesResponse, error)
	grpc.ClientStream
}

type bTrDBChangesClient struct {
	grpc.ClientStream
}

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

func (c *bTrDBClient) Insert(ctx context.Context, in *InsertParams, opts ...grpc.CallOption) (*InsertResponse, error) {
	out := new(InsertResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Insert", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Delete(ctx context.Context, in *DeleteParams, opts ...grpc.CallOption) (*DeleteResponse, error) {
	out := new(DeleteResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Delete", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Info(ctx context.Context, in *InfoParams, opts ...grpc.CallOption) (*InfoResponse, error) {
	out := new(InfoResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Info", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) FaultInject(ctx context.Context, in *FaultInjectParams, opts ...grpc.CallOption) (*FaultInjectResponse, error) {
	out := new(FaultInjectResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/FaultInject", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Flush(ctx context.Context, in *FlushParams, opts ...grpc.CallOption) (*FlushResponse, error) {
	out := new(FlushResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Flush", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *bTrDBClient) Obliterate(ctx context.Context, in *ObliterateParams, opts ...grpc.CallOption) (*ObliterateResponse, error) {
	out := new(ObliterateResponse)
	err := grpc.Invoke(ctx, "/grpcinterface.BTrDB/Obliterate", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for BTrDB service

type BTrDBServer interface {
	RawValues(*RawValuesParams, BTrDB_RawValuesServer) error
	AlignedWindows(*AlignedWindowsParams, BTrDB_AlignedWindowsServer) error
	Windows(*WindowsParams, BTrDB_WindowsServer) error
	StreamInfo(context.Context, *StreamInfoParams) (*StreamInfoResponse, error)
	SetStreamAnnotations(context.Context, *SetStreamAnnotationsParams) (*SetStreamAnnotationsResponse, error)
	Create(context.Context, *CreateParams) (*CreateResponse, error)
	ListCollections(context.Context, *ListCollectionsParams) (*ListCollectionsResponse, error)
	LookupStreams(*LookupStreamsParams, BTrDB_LookupStreamsServer) error
	Nearest(context.Context, *NearestParams) (*NearestResponse, error)
	Changes(*ChangesParams, BTrDB_ChangesServer) error
	Insert(context.Context, *InsertParams) (*InsertResponse, error)
	Delete(context.Context, *DeleteParams) (*DeleteResponse, error)
	Info(context.Context, *InfoParams) (*InfoResponse, error)
	FaultInject(context.Context, *FaultInjectParams) (*FaultInjectResponse, error)
	Flush(context.Context, *FlushParams) (*FlushResponse, error)
	Obliterate(context.Context, *ObliterateParams) (*ObliterateResponse, error)
}

func RegisterBTrDBServer(s *grpc.Server, srv BTrDBServer) {
	s.RegisterService(&_BTrDB_serviceDesc, srv)
}

func _BTrDB_RawValues_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RawValuesParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).RawValues(m, &bTrDBRawValuesServer{stream})
}

type BTrDB_RawValuesServer interface {
	Send(*RawValuesResponse) error
	grpc.ServerStream
}

type bTrDBRawValuesServer struct {
	grpc.ServerStream
}

func (x *bTrDBRawValuesServer) Send(m *RawValuesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BTrDB_AlignedWindows_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlignedWindowsParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).AlignedWindows(m, &bTrDBAlignedWindowsServer{stream})
}

type BTrDB_AlignedWindowsServer interface {
	Send(*AlignedWindowsResponse) error
	grpc.ServerStream
}

type bTrDBAlignedWindowsServer struct {
	grpc.ServerStream
}

func (x *bTrDBAlignedWindowsServer) Send(m *AlignedWindowsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BTrDB_Windows_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WindowsParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).Windows(m, &bTrDBWindowsServer{stream})
}

type BTrDB_WindowsServer interface {
	Send(*WindowsResponse) error
	grpc.ServerStream
}

type bTrDBWindowsServer struct {
	grpc.ServerStream
}

func (x *bTrDBWindowsServer) Send(m *WindowsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BTrDB_StreamInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamInfoParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).StreamInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/StreamInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).StreamInfo(ctx, req.(*StreamInfoParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_SetStreamAnnotations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetStreamAnnotationsParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).SetStreamAnnotations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/SetStreamAnnotations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).SetStreamAnnotations(ctx, req.(*SetStreamAnnotationsParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Create(ctx, req.(*CreateParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_ListCollections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCollectionsParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).ListCollections(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/ListCollections",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).ListCollections(ctx, req.(*ListCollectionsParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_LookupStreams_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LookupStreamsParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).LookupStreams(m, &bTrDBLookupStreamsServer{stream})
}

type BTrDB_LookupStreamsServer interface {
	Send(*LookupStreamsResponse) error
	grpc.ServerStream
}

type bTrDBLookupStreamsServer struct {
	grpc.ServerStream
}

func (x *bTrDBLookupStreamsServer) Send(m *LookupStreamsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BTrDB_Nearest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NearestParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Nearest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Nearest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Nearest(ctx, req.(*NearestParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Changes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ChangesParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).Changes(m, &bTrDBChangesServer{stream})
}

type BTrDB_ChangesServer interface {
	Send(*ChangesResponse) error
	grpc.ServerStream
}

type bTrDBChangesServer struct {
	grpc.ServerStream
}

func (x *bTrDBChangesServer) Send(m *ChangesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BTrDB_Insert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Insert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Insert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Insert(ctx, req.(*InsertParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Delete(ctx, req.(*DeleteParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InfoParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Info(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Info",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Info(ctx, req.(*InfoParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_FaultInject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FaultInjectParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).FaultInject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/FaultInject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).FaultInject(ctx, req.(*FaultInjectParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FlushParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Flush(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Flush",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Flush(ctx, req.(*FlushParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _BTrDB_Obliterate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ObliterateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BTrDBServer).Obliterate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcinterface.BTrDB/Obliterate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BTrDBServer).Obliterate(ctx, req.(*ObliterateParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _BTrDB_serviceDesc = grpc.ServiceDesc{
	ServiceName: "grpcinterface.BTrDB",
	HandlerType: (*BTrDBServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StreamInfo",
			Handler:    _BTrDB_StreamInfo_Handler,
		},
		{
			MethodName: "SetStreamAnnotations",
			Handler:    _BTrDB_SetStreamAnnotations_Handler,
		},
		{
			MethodName: "Create",
			Handler:    _BTrDB_Create_Handler,
		},
		{
			MethodName: "ListCollections",
			Handler:    _BTrDB_ListCollections_Handler,
		},
		{
			MethodName: "Nearest",
			Handler:    _BTrDB_Nearest_Handler,
		},
		{
			MethodName: "Insert",
			Handler:    _BTrDB_Insert_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _BTrDB_Delete_Handler,
		},
		{
			MethodName: "Info",
			Handler:    _BTrDB_Info_Handler,
		},
		{
			MethodName: "FaultInject",
			Handler:    _BTrDB_FaultInject_Handler,
		},
		{
			MethodName: "Flush",
			Handler:    _BTrDB_Flush_Handler,
		},
		{
			MethodName: "Obliterate",
			Handler:    _BTrDB_Obliterate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RawValues",
			Handler:       _BTrDB_RawValues_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "AlignedWindows",
			Handler:       _BTrDB_AlignedWindows_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Windows",
			Handler:       _BTrDB_Windows_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LookupStreams",
			Handler:       _BTrDB_LookupStreams_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Changes",
			Handler:       _BTrDB_Changes_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "btrdb.proto",
}

func init() { proto.RegisterFile("btrdb.proto", fileDescriptor0) }

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