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

package grpcinterface

/*
Version 4.2
*/

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 GenerateCSVParams_QueryType int32

const (
	GenerateCSVParams_ALIGNED_WINDOWS_QUERY GenerateCSVParams_QueryType = 0
	GenerateCSVParams_WINDOWS_QUERY         GenerateCSVParams_QueryType = 1
	GenerateCSVParams_RAW_QUERY             GenerateCSVParams_QueryType = 2
)

var GenerateCSVParams_QueryType_name = map[int32]string{
	0: "ALIGNED_WINDOWS_QUERY",
	1: "WINDOWS_QUERY",
	2: "RAW_QUERY",
}
var GenerateCSVParams_QueryType_value = map[string]int32{
	"ALIGNED_WINDOWS_QUERY": 0,
	"WINDOWS_QUERY":         1,
	"RAW_QUERY":             2,
}

func (x GenerateCSVParams_QueryType) String() string {
	return proto.EnumName(GenerateCSVParams_QueryType_name, int32(x))
}
func (GenerateCSVParams_QueryType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_btrdb_ebf2ceea5aa2fde5, []int{47, 0}
}

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RawValuesParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_RawValuesResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AlignedWindowsParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_AlignedWindowsResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WindowsParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_WindowsResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StreamInfoParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_StreamInfoResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_StreamDescriptor proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral      struct{}       `json:"-"`
	XXX_unrecognized          []byte         `json:"-"`
	XXX_sizecache             int32          `json:"-"`
}

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

var xxx_messageInfo_SetStreamAnnotationsParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SetStreamAnnotationsResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_CreateParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreateResponse proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_MetadataUsageParams proto.InternalMessageInfo

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

type MetadataUsageResponse struct {
	Stat                 *Status     `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	Tags                 []*KeyCount `protobuf:"bytes,2,rep,name=tags" json:"tags,omitempty"`
	Annotations          []*KeyCount `protobuf:"bytes,3,rep,name=annotations" json:"annotations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_MetadataUsageResponse proto.InternalMessageInfo

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

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

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

type KeyCount struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Count                uint64   `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_KeyCount proto.InternalMessageInfo

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

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

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListCollectionsParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListCollectionsResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_LookupStreamsParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_LookupStreamsResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NearestParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_NearestResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ChangesParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_ChangesResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_InsertParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InsertResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo

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 {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InfoParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_InfoResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ProxyInfo proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FaultInjectParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FaultInjectResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FlushParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FlushResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ObliterateParams proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ObliterateResponse proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RawPoint proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StatPoint proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ChangedRange proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Status proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_Mash proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Member proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_KeyOptValue proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_OptValue proto.InternalMessageInfo

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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_KeyValue proto.InternalMessageInfo

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
}

type StreamCSVConfig struct {
	Version              uint64   `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
	Label                string   `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
	Uuid                 []byte   `protobuf:"bytes,3,opt,name=uuid,proto3" json:"uuid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StreamCSVConfig proto.InternalMessageInfo

func (m *StreamCSVConfig) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *StreamCSVConfig) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

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

type GenerateCSVParams struct {
	QueryType            GenerateCSVParams_QueryType `protobuf:"varint,1,opt,name=queryType,enum=grpcinterface.GenerateCSVParams_QueryType" json:"queryType,omitempty"`
	StartTime            int64                       `protobuf:"varint,2,opt,name=startTime" json:"startTime,omitempty"`
	EndTime              int64                       `protobuf:"varint,3,opt,name=endTime" json:"endTime,omitempty"`
	WindowSize           uint64                      `protobuf:"varint,4,opt,name=windowSize" json:"windowSize,omitempty"`
	Depth                uint32                      `protobuf:"varint,5,opt,name=depth" json:"depth,omitempty"`
	IncludeVersions      bool                        `protobuf:"varint,6,opt,name=includeVersions" json:"includeVersions,omitempty"`
	Streams              []*StreamCSVConfig          `protobuf:"bytes,7,rep,name=streams" json:"streams,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_GenerateCSVParams proto.InternalMessageInfo

func (m *GenerateCSVParams) GetQueryType() GenerateCSVParams_QueryType {
	if m != nil {
		return m.QueryType
	}
	return GenerateCSVParams_ALIGNED_WINDOWS_QUERY
}

func (m *GenerateCSVParams) GetStartTime() int64 {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *GenerateCSVParams) GetEndTime() int64 {
	if m != nil {
		return m.EndTime
	}
	return 0
}

func (m *GenerateCSVParams) GetWindowSize() uint64 {
	if m != nil {
		return m.WindowSize
	}
	return 0
}

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

func (m *GenerateCSVParams) GetIncludeVersions() bool {
	if m != nil {
		return m.IncludeVersions
	}
	return false
}

func (m *GenerateCSVParams) GetStreams() []*StreamCSVConfig {
	if m != nil {
		return m.Streams
	}
	return nil
}

type GenerateCSVResponse struct {
	Stat                 *Status  `protobuf:"bytes,1,opt,name=stat" json:"stat,omitempty"`
	IsHeader             bool     `protobuf:"varint,2,opt,name=isHeader" json:"isHeader,omitempty"`
	Row                  []string `protobuf:"bytes,3,rep,name=row" json:"row,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GenerateCSVResponse proto.InternalMessageInfo

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

func (m *GenerateCSVResponse) GetIsHeader() bool {
	if m != nil {
		return m.IsHeader
	}
	return false
}

func (m *GenerateCSVResponse) GetRow() []string {
	if m != nil {
		return m.Row
	}
	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((*MetadataUsageParams)(nil), "grpcinterface.MetadataUsageParams")
	proto.RegisterType((*MetadataUsageResponse)(nil), "grpcinterface.MetadataUsageResponse")
	proto.RegisterType((*KeyCount)(nil), "grpcinterface.KeyCount")
	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")
	proto.RegisterType((*StreamCSVConfig)(nil), "grpcinterface.StreamCSVConfig")
	proto.RegisterType((*GenerateCSVParams)(nil), "grpcinterface.GenerateCSVParams")
	proto.RegisterType((*GenerateCSVResponse)(nil), "grpcinterface.GenerateCSVResponse")
	proto.RegisterEnum("grpcinterface.GenerateCSVParams_QueryType", GenerateCSVParams_QueryType_name, GenerateCSVParams_QueryType_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

// BTrDBClient is the client API for BTrDB service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
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)
	GetMetadataUsage(ctx context.Context, in *MetadataUsageParams, opts ...grpc.CallOption) (*MetadataUsageResponse, error)
	GenerateCSV(ctx context.Context, in *GenerateCSVParams, opts ...grpc.CallOption) (BTrDB_GenerateCSVClient, 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 := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[0], "/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 := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[1], "/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 := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[2], "/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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/StreamInfo", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/SetStreamAnnotations", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Create", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/ListCollections", in, out, 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 := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[3], "/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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Nearest", in, out, 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 := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[4], "/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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Insert", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Delete", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Info", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/FaultInject", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Flush", in, out, 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 := c.cc.Invoke(ctx, "/grpcinterface.BTrDB/Obliterate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *bTrDBClient) GenerateCSV(ctx context.Context, in *GenerateCSVParams, opts ...grpc.CallOption) (BTrDB_GenerateCSVClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BTrDB_serviceDesc.Streams[5], "/grpcinterface.BTrDB/GenerateCSV", opts...)
	if err != nil {
		return nil, err
	}
	x := &bTrDBGenerateCSVClient{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_GenerateCSVClient interface {
	Recv() (*GenerateCSVResponse, error)
	grpc.ClientStream
}

type bTrDBGenerateCSVClient struct {
	grpc.ClientStream
}

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

// BTrDBServer is the 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)
	GetMetadataUsage(context.Context, *MetadataUsageParams) (*MetadataUsageResponse, error)
	GenerateCSV(*GenerateCSVParams, BTrDB_GenerateCSVServer) 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)
}

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

func _BTrDB_GenerateCSV_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GenerateCSVParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BTrDBServer).GenerateCSV(m, &bTrDBGenerateCSVServer{stream})
}

type BTrDB_GenerateCSVServer interface {
	Send(*GenerateCSVResponse) error
	grpc.ServerStream
}

type bTrDBGenerateCSVServer struct {
	grpc.ServerStream
}

func (x *bTrDBGenerateCSVServer) Send(m *GenerateCSVResponse) error {
	return x.ServerStream.SendMsg(m)
}

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,
		},
		{
			MethodName: "GetMetadataUsage",
			Handler:    _BTrDB_GetMetadataUsage_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,
		},
		{
			StreamName:    "GenerateCSV",
			Handler:       _BTrDB_GenerateCSV_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "btrdb.proto",
}

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

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