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

package statdb

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

// Node is info for a updating a single storagenode, used in the Update rpc calls
type Node struct {
	NodeId               []byte   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	LatencyList          []int64  `protobuf:"varint,2,rep,packed,name=latency_list,json=latencyList,proto3" json:"latency_list,omitempty"`
	AuditSuccess         bool     `protobuf:"varint,3,opt,name=audit_success,json=auditSuccess,proto3" json:"audit_success,omitempty"`
	IsUp                 bool     `protobuf:"varint,4,opt,name=is_up,json=isUp,proto3" json:"is_up,omitempty"`
	UpdateLatency        bool     `protobuf:"varint,5,opt,name=update_latency,json=updateLatency,proto3" json:"update_latency,omitempty"`
	UpdateAuditSuccess   bool     `protobuf:"varint,6,opt,name=update_audit_success,json=updateAuditSuccess,proto3" json:"update_audit_success,omitempty"`
	UpdateUptime         bool     `protobuf:"varint,7,opt,name=update_uptime,json=updateUptime,proto3" json:"update_uptime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetNodeId() []byte {
	if m != nil {
		return m.NodeId
	}
	return nil
}

func (m *Node) GetLatencyList() []int64 {
	if m != nil {
		return m.LatencyList
	}
	return nil
}

func (m *Node) GetAuditSuccess() bool {
	if m != nil {
		return m.AuditSuccess
	}
	return false
}

func (m *Node) GetIsUp() bool {
	if m != nil {
		return m.IsUp
	}
	return false
}

func (m *Node) GetUpdateLatency() bool {
	if m != nil {
		return m.UpdateLatency
	}
	return false
}

func (m *Node) GetUpdateAuditSuccess() bool {
	if m != nil {
		return m.UpdateAuditSuccess
	}
	return false
}

func (m *Node) GetUpdateUptime() bool {
	if m != nil {
		return m.UpdateUptime
	}
	return false
}

// NodeStats is info about a single storagenode stored in the stats db
type NodeStats struct {
	NodeId               []byte   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Latency_90           int64    `protobuf:"varint,2,opt,name=latency_90,json=latency90,proto3" json:"latency_90,omitempty"`
	AuditSuccessRatio    float64  `protobuf:"fixed64,3,opt,name=audit_success_ratio,json=auditSuccessRatio,proto3" json:"audit_success_ratio,omitempty"`
	UptimeRatio          float64  `protobuf:"fixed64,4,opt,name=uptime_ratio,json=uptimeRatio,proto3" json:"uptime_ratio,omitempty"`
	AuditCount           int64    `protobuf:"varint,5,opt,name=audit_count,json=auditCount,proto3" json:"audit_count,omitempty"`
	AuditSuccessCount    int64    `protobuf:"varint,6,opt,name=audit_success_count,json=auditSuccessCount,proto3" json:"audit_success_count,omitempty"`
	UptimeCount          int64    `protobuf:"varint,7,opt,name=uptime_count,json=uptimeCount,proto3" json:"uptime_count,omitempty"`
	UptimeSuccessCount   int64    `protobuf:"varint,8,opt,name=uptime_success_count,json=uptimeSuccessCount,proto3" json:"uptime_success_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NodeStats proto.InternalMessageInfo

func (m *NodeStats) GetNodeId() []byte {
	if m != nil {
		return m.NodeId
	}
	return nil
}

func (m *NodeStats) GetLatency_90() int64 {
	if m != nil {
		return m.Latency_90
	}
	return 0
}

func (m *NodeStats) GetAuditSuccessRatio() float64 {
	if m != nil {
		return m.AuditSuccessRatio
	}
	return 0
}

func (m *NodeStats) GetUptimeRatio() float64 {
	if m != nil {
		return m.UptimeRatio
	}
	return 0
}

func (m *NodeStats) GetAuditCount() int64 {
	if m != nil {
		return m.AuditCount
	}
	return 0
}

func (m *NodeStats) GetAuditSuccessCount() int64 {
	if m != nil {
		return m.AuditSuccessCount
	}
	return 0
}

func (m *NodeStats) GetUptimeCount() int64 {
	if m != nil {
		return m.UptimeCount
	}
	return 0
}

func (m *NodeStats) GetUptimeSuccessCount() int64 {
	if m != nil {
		return m.UptimeSuccessCount
	}
	return 0
}

// CreateRequest is a request message for the Create rpc call
type CreateRequest struct {
	Node                 *Node      `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Stats                *NodeStats `protobuf:"bytes,2,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_CreateRequest proto.InternalMessageInfo

func (m *CreateRequest) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *CreateRequest) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// CreateResponse is a response message for the Create rpc call
type CreateResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,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_statdb_823b3386d7576b72, []int{3}
}
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) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// GetRequest is a request message for the Get rpc call
type GetRequest struct {
	NodeId               []byte   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetRequest proto.InternalMessageInfo

func (m *GetRequest) GetNodeId() []byte {
	if m != nil {
		return m.NodeId
	}
	return nil
}

// GetResponse is a response message for the Get rpc call
type GetResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_GetResponse proto.InternalMessageInfo

func (m *GetResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// FindValidNodesRequest is a request message for the FindValidNodes rpc call
type FindValidNodesRequest struct {
	NodeIds              [][]byte   `protobuf:"bytes,1,rep,name=node_ids,json=nodeIds,proto3" json:"node_ids,omitempty"`
	MinStats             *NodeStats `protobuf:"bytes,2,opt,name=min_stats,json=minStats,proto3" json:"min_stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_FindValidNodesRequest proto.InternalMessageInfo

func (m *FindValidNodesRequest) GetNodeIds() [][]byte {
	if m != nil {
		return m.NodeIds
	}
	return nil
}

func (m *FindValidNodesRequest) GetMinStats() *NodeStats {
	if m != nil {
		return m.MinStats
	}
	return nil
}

// FindValidNodesResponse is a response message for the FindValidNodes rpc call
type FindValidNodesResponse struct {
	PassedIds            [][]byte `protobuf:"bytes,1,rep,name=passed_ids,json=passedIds,proto3" json:"passed_ids,omitempty"`
	FailedIds            [][]byte `protobuf:"bytes,2,rep,name=failed_ids,json=failedIds,proto3" json:"failed_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FindValidNodesResponse proto.InternalMessageInfo

func (m *FindValidNodesResponse) GetPassedIds() [][]byte {
	if m != nil {
		return m.PassedIds
	}
	return nil
}

func (m *FindValidNodesResponse) GetFailedIds() [][]byte {
	if m != nil {
		return m.FailedIds
	}
	return nil
}

// UpdateRequest is a request message for the Update rpc call
type UpdateRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo

func (m *UpdateRequest) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// UpdateRequest is a response message for the Update rpc call
type UpdateResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo

func (m *UpdateResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateUptimeRequest is a request message for the UpdateUptime rpc call
type UpdateUptimeRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateUptimeRequest proto.InternalMessageInfo

func (m *UpdateUptimeRequest) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// UpdateUptimeResponse is a response message for the UpdateUptime rpc call
type UpdateUptimeResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_UpdateUptimeResponse proto.InternalMessageInfo

func (m *UpdateUptimeResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateAuditSuccessRequest is a request message for the UpdateAuditSuccess rpc call
type UpdateAuditSuccessRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateAuditSuccessRequest proto.InternalMessageInfo

func (m *UpdateAuditSuccessRequest) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// UpdateAuditSuccessResponse is a response message for the UpdateAuditSuccess rpc call
type UpdateAuditSuccessResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_UpdateAuditSuccessResponse proto.InternalMessageInfo

func (m *UpdateAuditSuccessResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateBatchRequest is a request message for the UpdateBatch rpc call
type UpdateBatchRequest struct {
	NodeList             []*Node  `protobuf:"bytes,1,rep,name=node_list,json=nodeList,proto3" json:"node_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateBatchRequest proto.InternalMessageInfo

func (m *UpdateBatchRequest) GetNodeList() []*Node {
	if m != nil {
		return m.NodeList
	}
	return nil
}

// UpdateBatchResponse is a response message for the UpdateBatch rpc call
type UpdateBatchResponse struct {
	StatsList            []*NodeStats `protobuf:"bytes,1,rep,name=stats_list,json=statsList,proto3" json:"stats_list,omitempty"`
	FailedNodes          []*Node      `protobuf:"bytes,2,rep,name=failed_nodes,json=failedNodes,proto3" json:"failed_nodes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_UpdateBatchResponse proto.InternalMessageInfo

func (m *UpdateBatchResponse) GetStatsList() []*NodeStats {
	if m != nil {
		return m.StatsList
	}
	return nil
}

func (m *UpdateBatchResponse) GetFailedNodes() []*Node {
	if m != nil {
		return m.FailedNodes
	}
	return nil
}

// CreateEntryIfNotExistsRequest is a request message for the CreateEntryIfNotExists rpc call
type CreateEntryIfNotExistsRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreateEntryIfNotExistsRequest proto.InternalMessageInfo

func (m *CreateEntryIfNotExistsRequest) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// CreateEntryIfNotExistsResponse is a response message for the CreateEntryIfNotExists rpc call
type CreateEntryIfNotExistsResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_CreateEntryIfNotExistsResponse proto.InternalMessageInfo

func (m *CreateEntryIfNotExistsResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func init() {
	proto.RegisterType((*Node)(nil), "statdb.Node")
	proto.RegisterType((*NodeStats)(nil), "statdb.NodeStats")
	proto.RegisterType((*CreateRequest)(nil), "statdb.CreateRequest")
	proto.RegisterType((*CreateResponse)(nil), "statdb.CreateResponse")
	proto.RegisterType((*GetRequest)(nil), "statdb.GetRequest")
	proto.RegisterType((*GetResponse)(nil), "statdb.GetResponse")
	proto.RegisterType((*FindValidNodesRequest)(nil), "statdb.FindValidNodesRequest")
	proto.RegisterType((*FindValidNodesResponse)(nil), "statdb.FindValidNodesResponse")
	proto.RegisterType((*UpdateRequest)(nil), "statdb.UpdateRequest")
	proto.RegisterType((*UpdateResponse)(nil), "statdb.UpdateResponse")
	proto.RegisterType((*UpdateUptimeRequest)(nil), "statdb.UpdateUptimeRequest")
	proto.RegisterType((*UpdateUptimeResponse)(nil), "statdb.UpdateUptimeResponse")
	proto.RegisterType((*UpdateAuditSuccessRequest)(nil), "statdb.UpdateAuditSuccessRequest")
	proto.RegisterType((*UpdateAuditSuccessResponse)(nil), "statdb.UpdateAuditSuccessResponse")
	proto.RegisterType((*UpdateBatchRequest)(nil), "statdb.UpdateBatchRequest")
	proto.RegisterType((*UpdateBatchResponse)(nil), "statdb.UpdateBatchResponse")
	proto.RegisterType((*CreateEntryIfNotExistsRequest)(nil), "statdb.CreateEntryIfNotExistsRequest")
	proto.RegisterType((*CreateEntryIfNotExistsResponse)(nil), "statdb.CreateEntryIfNotExistsResponse")
}

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

// StatDBClient is the client API for StatDB service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StatDBClient interface {
	// Create a db entry for the provided storagenode ID
	Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
	// Get uses a storagenode ID to get that storagenode's stats
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// FindValidNodes gets a subset of storagenodes that fit minimum reputation args
	FindValidNodes(ctx context.Context, in *FindValidNodesRequest, opts ...grpc.CallOption) (*FindValidNodesResponse, error)
	// Update updates all stats for a single storagenode
	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
	// UpdateUptime updates uptime stats for a single storagenode
	UpdateUptime(ctx context.Context, in *UpdateUptimeRequest, opts ...grpc.CallOption) (*UpdateUptimeResponse, error)
	// UpdateAuditSuccess updates audit success stats for a single storagenode
	UpdateAuditSuccess(ctx context.Context, in *UpdateAuditSuccessRequest, opts ...grpc.CallOption) (*UpdateAuditSuccessResponse, error)
	// UpdateBatch updates storagenode stats for multiple farmers at a time
	UpdateBatch(ctx context.Context, in *UpdateBatchRequest, opts ...grpc.CallOption) (*UpdateBatchResponse, error)
	// CreateEntryIfNotExists creates a db entry if it didn't exist
	CreateEntryIfNotExists(ctx context.Context, in *CreateEntryIfNotExistsRequest, opts ...grpc.CallOption) (*CreateEntryIfNotExistsResponse, error)
}

type statDBClient struct {
	cc *grpc.ClientConn
}

func NewStatDBClient(cc *grpc.ClientConn) StatDBClient {
	return &statDBClient{cc}
}

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

func (c *statDBClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) FindValidNodes(ctx context.Context, in *FindValidNodesRequest, opts ...grpc.CallOption) (*FindValidNodesResponse, error) {
	out := new(FindValidNodesResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/FindValidNodes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
	out := new(UpdateResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateUptime(ctx context.Context, in *UpdateUptimeRequest, opts ...grpc.CallOption) (*UpdateUptimeResponse, error) {
	out := new(UpdateUptimeResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateUptime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateAuditSuccess(ctx context.Context, in *UpdateAuditSuccessRequest, opts ...grpc.CallOption) (*UpdateAuditSuccessResponse, error) {
	out := new(UpdateAuditSuccessResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateAuditSuccess", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateBatch(ctx context.Context, in *UpdateBatchRequest, opts ...grpc.CallOption) (*UpdateBatchResponse, error) {
	out := new(UpdateBatchResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) CreateEntryIfNotExists(ctx context.Context, in *CreateEntryIfNotExistsRequest, opts ...grpc.CallOption) (*CreateEntryIfNotExistsResponse, error) {
	out := new(CreateEntryIfNotExistsResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/CreateEntryIfNotExists", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// StatDBServer is the server API for StatDB service.
type StatDBServer interface {
	// Create a db entry for the provided storagenode ID
	Create(context.Context, *CreateRequest) (*CreateResponse, error)
	// Get uses a storagenode ID to get that storagenode's stats
	Get(context.Context, *GetRequest) (*GetResponse, error)
	// FindValidNodes gets a subset of storagenodes that fit minimum reputation args
	FindValidNodes(context.Context, *FindValidNodesRequest) (*FindValidNodesResponse, error)
	// Update updates all stats for a single storagenode
	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
	// UpdateUptime updates uptime stats for a single storagenode
	UpdateUptime(context.Context, *UpdateUptimeRequest) (*UpdateUptimeResponse, error)
	// UpdateAuditSuccess updates audit success stats for a single storagenode
	UpdateAuditSuccess(context.Context, *UpdateAuditSuccessRequest) (*UpdateAuditSuccessResponse, error)
	// UpdateBatch updates storagenode stats for multiple farmers at a time
	UpdateBatch(context.Context, *UpdateBatchRequest) (*UpdateBatchResponse, error)
	// CreateEntryIfNotExists creates a db entry if it didn't exist
	CreateEntryIfNotExists(context.Context, *CreateEntryIfNotExistsRequest) (*CreateEntryIfNotExistsResponse, error)
}

func RegisterStatDBServer(s *grpc.Server, srv StatDBServer) {
	s.RegisterService(&_StatDB_serviceDesc, srv)
}

func _StatDB_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Create(ctx, req.(*CreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Get(ctx, req.(*GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_FindValidNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindValidNodesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).FindValidNodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/FindValidNodes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).FindValidNodes(ctx, req.(*FindValidNodesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Update(ctx, req.(*UpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateUptime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateUptimeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateUptime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateUptime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateUptime(ctx, req.(*UpdateUptimeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateAuditSuccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAuditSuccessRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateAuditSuccess(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateAuditSuccess",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateAuditSuccess(ctx, req.(*UpdateAuditSuccessRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateBatch(ctx, req.(*UpdateBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_CreateEntryIfNotExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateEntryIfNotExistsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).CreateEntryIfNotExists(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/CreateEntryIfNotExists",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).CreateEntryIfNotExists(ctx, req.(*CreateEntryIfNotExistsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _StatDB_serviceDesc = grpc.ServiceDesc{
	ServiceName: "statdb.StatDB",
	HandlerType: (*StatDBServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _StatDB_Create_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _StatDB_Get_Handler,
		},
		{
			MethodName: "FindValidNodes",
			Handler:    _StatDB_FindValidNodes_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _StatDB_Update_Handler,
		},
		{
			MethodName: "UpdateUptime",
			Handler:    _StatDB_UpdateUptime_Handler,
		},
		{
			MethodName: "UpdateAuditSuccess",
			Handler:    _StatDB_UpdateAuditSuccess_Handler,
		},
		{
			MethodName: "UpdateBatch",
			Handler:    _StatDB_UpdateBatch_Handler,
		},
		{
			MethodName: "CreateEntryIfNotExists",
			Handler:    _StatDB_CreateEntryIfNotExists_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "statdb.proto",
}

func init() { proto.RegisterFile("statdb.proto", fileDescriptor_statdb_823b3386d7576b72) }

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