service.pb.go

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

package proto

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

type Client struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
	EmailAddress         string   `protobuf:"bytes,3,opt,name=emailAddress,proto3" json:"emailAddress,omitempty"`
	MacAddress           string   `protobuf:"bytes,4,opt,name=macAddress,proto3" json:"macAddress,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Client proto.InternalMessageInfo

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

func (m *Client) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Client) GetEmailAddress() string {
	if m != nil {
		return m.EmailAddress
	}
	return ""
}

func (m *Client) GetMacAddress() string {
	if m != nil {
		return m.MacAddress
	}
	return ""
}

// Used in direct messaging
type Message struct {
	Type            string           `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty"`
	Sender          *Node            `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	Policy          *Policy          `protobuf:"bytes,3,opt,name=policy,proto3" json:"policy,omitempty"`
	Signature       *MsgSignature    `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"`
	GossipMessage   *GossipMessage   `protobuf:"bytes,6,opt,name=gossipMessage,proto3" json:"gossipMessage,omitempty"`
	Probe           *Probe           `protobuf:"bytes,7,opt,name=probe,proto3" json:"probe,omitempty"`
	DatasetRequest  *DatasetRequest  `protobuf:"bytes,8,opt,name=datasetRequest,proto3" json:"datasetRequest,omitempty"`
	DatasetResponse *DatasetResponse `protobuf:"bytes,9,opt,name=datasetResponse,proto3" json:"datasetResponse,omitempty"`
	PolicyRequest   *PolicyRequest   `protobuf:"bytes,10,opt,name=policyRequest,proto3" json:"policyRequest,omitempty"`
	//DatasetIdentifierStateRequest datasetIdentifierStateRequest = 11;
	//    DatasetDeltaRequest datasetDeltaRequest = 11;
	//    DatasetDeltaResponse DatasetDeltaResponse = 12;
	DatasetCollectionSummary *DatasetCollectionSummary `protobuf:"bytes,13,opt,name=datasetCollectionSummary,proto3" json:"datasetCollectionSummary,omitempty"`
	// Other fields
	StringValue          string   `protobuf:"bytes,14,opt,name=stringValue,proto3" json:"stringValue,omitempty"`
	StringSlice          []string `protobuf:"bytes,15,rep,name=stringSlice,proto3" json:"stringSlice,omitempty"`
	Bytes                []byte   `protobuf:"bytes,16,opt,name=Bytes,proto3" json:"Bytes,omitempty"`
	BytesSlice           [][]byte `protobuf:"bytes,17,rep,name=BytesSlice,proto3" json:"BytesSlice,omitempty"`
	BoolValue            bool     `protobuf:"varint,18,opt,name=boolValue,proto3" json:"boolValue,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Message proto.InternalMessageInfo

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

func (m *Message) GetSender() *Node {
	if m != nil {
		return m.Sender
	}
	return nil
}

func (m *Message) GetPolicy() *Policy {
	if m != nil {
		return m.Policy
	}
	return nil
}

func (m *Message) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *Message) GetGossipMessage() *GossipMessage {
	if m != nil {
		return m.GossipMessage
	}
	return nil
}

func (m *Message) GetProbe() *Probe {
	if m != nil {
		return m.Probe
	}
	return nil
}

func (m *Message) GetDatasetRequest() *DatasetRequest {
	if m != nil {
		return m.DatasetRequest
	}
	return nil
}

func (m *Message) GetDatasetResponse() *DatasetResponse {
	if m != nil {
		return m.DatasetResponse
	}
	return nil
}

func (m *Message) GetPolicyRequest() *PolicyRequest {
	if m != nil {
		return m.PolicyRequest
	}
	return nil
}

func (m *Message) GetDatasetCollectionSummary() *DatasetCollectionSummary {
	if m != nil {
		return m.DatasetCollectionSummary
	}
	return nil
}

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

func (m *Message) GetStringSlice() []string {
	if m != nil {
		return m.StringSlice
	}
	return nil
}

func (m *Message) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *Message) GetBytesSlice() [][]byte {
	if m != nil {
		return m.BytesSlice
	}
	return nil
}

func (m *Message) GetBoolValue() bool {
	if m != nil {
		return m.BoolValue
	}
	return false
}

type Response struct {
	Signature            *MsgSignature `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	StringValue          string        `protobuf:"bytes,2,opt,name=stringValue,proto3" json:"stringValue,omitempty"`
	StringSlice          []string      `protobuf:"bytes,3,rep,name=stringSlice,proto3" json:"stringSlice,omitempty"`
	BytesValue           []byte        `protobuf:"bytes,4,opt,name=bytesValue,proto3" json:"bytesValue,omitempty"`
	BytesSlice           [][]byte      `protobuf:"bytes,5,rep,name=bytesSlice,proto3" json:"bytesSlice,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Response proto.InternalMessageInfo

func (m *Response) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *Response) GetStringValue() string {
	if m != nil {
		return m.StringValue
	}
	return ""
}

func (m *Response) GetStringSlice() []string {
	if m != nil {
		return m.StringSlice
	}
	return nil
}

func (m *Response) GetBytesValue() []byte {
	if m != nil {
		return m.BytesValue
	}
	return nil
}

func (m *Response) GetBytesSlice() [][]byte {
	if m != nil {
		return m.BytesSlice
	}
	return nil
}

// Here, node is Lohpi storage nodes, policy store and mux (and compliance engine?)
type Node struct {
	Name                 string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	IfritAddress         string               `protobuf:"bytes,2,opt,name=ifritAddress,proto3" json:"ifritAddress,omitempty"`
	Id                   []byte               `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	HttpsAddress         string               `protobuf:"bytes,4,opt,name=httpsAddress,proto3" json:"httpsAddress,omitempty"`
	Port                 int32                `protobuf:"varint,5,opt,name=port,proto3" json:"port,omitempty"`
	BootTime             *timestamp.Timestamp `protobuf:"bytes,6,opt,name=bootTime,proto3" json:"bootTime,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_a0b84a42fa06f626, []int{3}
}

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 (m *Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Node.Merge(m, 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) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Node) GetIfritAddress() string {
	if m != nil {
		return m.IfritAddress
	}
	return ""
}

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

func (m *Node) GetHttpsAddress() string {
	if m != nil {
		return m.HttpsAddress
	}
	return ""
}

func (m *Node) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *Node) GetBootTime() *timestamp.Timestamp {
	if m != nil {
		return m.BootTime
	}
	return nil
}

type DatasetRequest struct {
	Identifier           string        `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	ClientToken          []byte        `protobuf:"bytes,2,opt,name=clientToken,proto3" json:"clientToken,omitempty"`
	Signature            *MsgSignature `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_DatasetRequest proto.InternalMessageInfo

func (m *DatasetRequest) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func (m *DatasetRequest) GetClientToken() []byte {
	if m != nil {
		return m.ClientToken
	}
	return nil
}

func (m *DatasetRequest) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type Dataset struct {
	Identifier             string   `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	Policy                 *Policy  `protobuf:"bytes,2,opt,name=policy,proto3" json:"policy,omitempty"`
	AllowMultipleCheckouts bool     `protobuf:"varint,3,opt,name=allowMultipleCheckouts,proto3" json:"allowMultipleCheckouts,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

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

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

var xxx_messageInfo_Dataset proto.InternalMessageInfo

func (m *Dataset) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func (m *Dataset) GetPolicy() *Policy {
	if m != nil {
		return m.Policy
	}
	return nil
}

func (m *Dataset) GetAllowMultipleCheckouts() bool {
	if m != nil {
		return m.AllowMultipleCheckouts
	}
	return false
}

type DatasetCheckout struct {
	DatasetIdentifier    string               `protobuf:"bytes,1,opt,name=datasetIdentifier,proto3" json:"datasetIdentifier,omitempty"`
	DateCheckout         *timestamp.Timestamp `protobuf:"bytes,3,opt,name=DateCheckout,proto3" json:"DateCheckout,omitempty"`
	Client               *Client              `protobuf:"bytes,4,opt,name=client,proto3" json:"client,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_DatasetCheckout proto.InternalMessageInfo

func (m *DatasetCheckout) GetDatasetIdentifier() string {
	if m != nil {
		return m.DatasetIdentifier
	}
	return ""
}

func (m *DatasetCheckout) GetDateCheckout() *timestamp.Timestamp {
	if m != nil {
		return m.DateCheckout
	}
	return nil
}

func (m *DatasetCheckout) GetClient() *Client {
	if m != nil {
		return m.Client
	}
	return nil
}

type DatasetResponse struct {
	Type                 string        `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty"`
	URL                  string        `protobuf:"bytes,2,opt,name=URL,proto3" json:"URL,omitempty"`
	IsAllowed            bool          `protobuf:"varint,3,opt,name=isAllowed,proto3" json:"isAllowed,omitempty"`
	ErrorMessage         string        `protobuf:"bytes,4,opt,name=errorMessage,proto3" json:"errorMessage,omitempty"`
	Signature            *MsgSignature `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_DatasetResponse proto.InternalMessageInfo

func (m *DatasetResponse) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *DatasetResponse) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *DatasetResponse) GetIsAllowed() bool {
	if m != nil {
		return m.IsAllowed
	}
	return false
}

func (m *DatasetResponse) GetErrorMessage() string {
	if m != nil {
		return m.ErrorMessage
	}
	return ""
}

func (m *DatasetResponse) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type ClientState struct {
	LastPolicyUpdate     *timestamp.Timestamp `protobuf:"bytes,1,opt,name=LastPolicyUpdate,proto3" json:"LastPolicyUpdate,omitempty"`
	LastComplyCheck      *timestamp.Timestamp `protobuf:"bytes,2,opt,name=LastComplyCheck,proto3" json:"LastComplyCheck,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_ClientState proto.InternalMessageInfo

func (m *ClientState) GetLastPolicyUpdate() *timestamp.Timestamp {
	if m != nil {
		return m.LastPolicyUpdate
	}
	return nil
}

func (m *ClientState) GetLastComplyCheck() *timestamp.Timestamp {
	if m != nil {
		return m.LastComplyCheck
	}
	return nil
}

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

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

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

var xxx_messageInfo_PolicyRequest proto.InternalMessageInfo

func (m *PolicyRequest) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

type MetadataRequest struct {
	Identifier           string        `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	ClientToken          []byte        `protobuf:"bytes,2,opt,name=clientToken,proto3" json:"clientToken,omitempty"`
	Signature            *MsgSignature `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_MetadataRequest proto.InternalMessageInfo

func (m *MetadataRequest) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func (m *MetadataRequest) GetClientToken() []byte {
	if m != nil {
		return m.ClientToken
	}
	return nil
}

func (m *MetadataRequest) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type MetadataResponse struct {
	URL                  string        `protobuf:"bytes,1,opt,name=URL,proto3" json:"URL,omitempty"`
	Signature            *MsgSignature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_MetadataResponse proto.InternalMessageInfo

func (m *MetadataResponse) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *MetadataResponse) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type Policy struct {
	DatasetIdentifier    string               `protobuf:"bytes,2,opt,name=datasetIdentifier,proto3" json:"datasetIdentifier,omitempty"`
	Content              bool                 `protobuf:"varint,3,opt,name=content,proto3" json:"content,omitempty"`
	Version              uint64               `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	DateCreated          *timestamp.Timestamp `protobuf:"bytes,5,opt,name=DateCreated,proto3" json:"DateCreated,omitempty"`
	DateApplied          *timestamp.Timestamp `protobuf:"bytes,6,opt,name=DateApplied,proto3" json:"DateApplied,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_Policy proto.InternalMessageInfo

func (m *Policy) GetDatasetIdentifier() string {
	if m != nil {
		return m.DatasetIdentifier
	}
	return ""
}

func (m *Policy) GetContent() bool {
	if m != nil {
		return m.Content
	}
	return false
}

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

func (m *Policy) GetDateCreated() *timestamp.Timestamp {
	if m != nil {
		return m.DateCreated
	}
	return nil
}

func (m *Policy) GetDateApplied() *timestamp.Timestamp {
	if m != nil {
		return m.DateApplied
	}
	return nil
}

type MsgSignature struct {
	R                    []byte   `protobuf:"bytes,1,opt,name=r,proto3" json:"r,omitempty"`
	S                    []byte   `protobuf:"bytes,2,opt,name=s,proto3" json:"s,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_MsgSignature proto.InternalMessageInfo

func (m *MsgSignature) GetR() []byte {
	if m != nil {
		return m.R
	}
	return nil
}

func (m *MsgSignature) GetS() []byte {
	if m != nil {
		return m.S
	}
	return nil
}

type HandshakeResponse struct {
	Ip                   string   `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Id                   []byte   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_HandshakeResponse proto.InternalMessageInfo

func (m *HandshakeResponse) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *HandshakeResponse) GetId() []byte {
	if m != nil {
		return m.Id
	}
	return nil
}

// Fix later
type GossipMessage struct {
	Sender               string               `protobuf:"bytes,1,opt,name=Sender,proto3" json:"Sender,omitempty"`
	MessageType          string               `protobuf:"bytes,2,opt,name=MessageType,proto3" json:"MessageType,omitempty"`
	DateSent             *timestamp.Timestamp `protobuf:"bytes,3,opt,name=DateSent,proto3" json:"DateSent,omitempty"`
	Signature            *MsgSignature        `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	GossipMessageBody    []*GossipMessageBody `protobuf:"bytes,5,rep,name=gossipMessageBody,proto3" json:"gossipMessageBody,omitempty"`
	GossipMessageID      *GossipMessageID     `protobuf:"bytes,6,opt,name=gossipMessageID,proto3" json:"gossipMessageID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_GossipMessage proto.InternalMessageInfo

func (m *GossipMessage) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *GossipMessage) GetMessageType() string {
	if m != nil {
		return m.MessageType
	}
	return ""
}

func (m *GossipMessage) GetDateSent() *timestamp.Timestamp {
	if m != nil {
		return m.DateSent
	}
	return nil
}

func (m *GossipMessage) GetSignature() *MsgSignature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *GossipMessage) GetGossipMessageBody() []*GossipMessageBody {
	if m != nil {
		return m.GossipMessageBody
	}
	return nil
}

func (m *GossipMessage) GetGossipMessageID() *GossipMessageID {
	if m != nil {
		return m.GossipMessageID
	}
	return nil
}

type GossipMessageID struct {
	PolicyStoreID        string   `protobuf:"bytes,1,opt,name=PolicyStoreID,proto3" json:"PolicyStoreID,omitempty"`
	SequenceNumber       int32    `protobuf:"varint,2,opt,name=SequenceNumber,proto3" json:"SequenceNumber,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GossipMessageID proto.InternalMessageInfo

func (m *GossipMessageID) GetPolicyStoreID() string {
	if m != nil {
		return m.PolicyStoreID
	}
	return ""
}

func (m *GossipMessageID) GetSequenceNumber() int32 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

type GossipMessageBody struct {
	Policy               *Policy  `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GossipMessageBody proto.InternalMessageInfo

func (m *GossipMessageBody) GetPolicy() *Policy {
	if m != nil {
		return m.Policy
	}
	return nil
}

type Probe struct {
	Order                uint32   `protobuf:"varint,1,opt,name=order,proto3" json:"order,omitempty"`
	SessionId            []byte   `protobuf:"bytes,2,opt,name=sessionId,proto3" json:"sessionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Probe proto.InternalMessageInfo

func (m *Probe) GetOrder() uint32 {
	if m != nil {
		return m.Order
	}
	return 0
}

func (m *Probe) GetSessionId() []byte {
	if m != nil {
		return m.SessionId
	}
	return nil
}

// TODO all messages below here should be put in its separate package that concerns
// consistency in the network. It should be treated as a lower-level abstraction.
type MembershipState struct {
	JoinTime             *timestamp.Timestamp `protobuf:"bytes,1,opt,name=joinTime,proto3" json:"joinTime,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_MembershipState proto.InternalMessageInfo

func (m *MembershipState) GetJoinTime() *timestamp.Timestamp {
	if m != nil {
		return m.JoinTime
	}
	return nil
}

// Send from the node to LDS/PS
type DatasetCollectionSummary struct {
	DatasetMap           map[string]*Dataset `protobuf:"bytes,2,rep,name=datasetMap,proto3" json:"datasetMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_DatasetCollectionSummary proto.InternalMessageInfo

func (m *DatasetCollectionSummary) GetDatasetMap() map[string]*Dataset {
	if m != nil {
		return m.DatasetMap
	}
	return nil
}

func init() {
	proto.RegisterType((*Client)(nil), "proto.Client")
	proto.RegisterType((*Message)(nil), "proto.Message")
	proto.RegisterType((*Response)(nil), "proto.Response")
	proto.RegisterType((*Node)(nil), "proto.Node")
	proto.RegisterType((*DatasetRequest)(nil), "proto.DatasetRequest")
	proto.RegisterType((*Dataset)(nil), "proto.Dataset")
	proto.RegisterType((*DatasetCheckout)(nil), "proto.DatasetCheckout")
	proto.RegisterType((*DatasetResponse)(nil), "proto.DatasetResponse")
	proto.RegisterType((*ClientState)(nil), "proto.ClientState")
	proto.RegisterType((*PolicyRequest)(nil), "proto.PolicyRequest")
	proto.RegisterType((*MetadataRequest)(nil), "proto.MetadataRequest")
	proto.RegisterType((*MetadataResponse)(nil), "proto.MetadataResponse")
	proto.RegisterType((*Policy)(nil), "proto.Policy")
	proto.RegisterType((*MsgSignature)(nil), "proto.MsgSignature")
	proto.RegisterType((*HandshakeResponse)(nil), "proto.HandshakeResponse")
	proto.RegisterType((*GossipMessage)(nil), "proto.GossipMessage")
	proto.RegisterType((*GossipMessageID)(nil), "proto.GossipMessageID")
	proto.RegisterType((*GossipMessageBody)(nil), "proto.GossipMessageBody")
	proto.RegisterType((*Probe)(nil), "proto.Probe")
	proto.RegisterType((*MembershipState)(nil), "proto.MembershipState")
	proto.RegisterType((*DatasetCollectionSummary)(nil), "proto.DatasetCollectionSummary")
	proto.RegisterMapType((map[string]*Dataset)(nil), "proto.DatasetCollectionSummary.DatasetMapEntry")
}

func init() { proto.RegisterFile("service.proto", fileDescriptor_a0b84a42fa06f626) }

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

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

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

// DirectoryServerClient is the client API for DirectoryServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DirectoryServerClient interface {
	Handshake(ctx context.Context, in *Node, opts ...grpc.CallOption) (*HandshakeResponse, error)
}

type directoryServerClient struct {
	cc *grpc.ClientConn
}

func NewDirectoryServerClient(cc *grpc.ClientConn) DirectoryServerClient {
	return &directoryServerClient{cc}
}

func (c *directoryServerClient) Handshake(ctx context.Context, in *Node, opts ...grpc.CallOption) (*HandshakeResponse, error) {
	out := new(HandshakeResponse)
	err := c.cc.Invoke(ctx, "/proto.DirectoryServer/Handshake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DirectoryServerServer is the server API for DirectoryServer service.
type DirectoryServerServer interface {
	Handshake(context.Context, *Node) (*HandshakeResponse, error)
}

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

func (*UnimplementedDirectoryServerServer) Handshake(ctx context.Context, req *Node) (*HandshakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Handshake not implemented")
}

func RegisterDirectoryServerServer(s *grpc.Server, srv DirectoryServerServer) {
	s.RegisterService(&_DirectoryServer_serviceDesc, srv)
}

func _DirectoryServer_Handshake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Node)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DirectoryServerServer).Handshake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.DirectoryServer/Handshake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DirectoryServerServer).Handshake(ctx, req.(*Node))
	}
	return interceptor(ctx, in, info, handler)
}

var _DirectoryServer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.DirectoryServer",
	HandlerType: (*DirectoryServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Handshake",
			Handler:    _DirectoryServer_Handshake_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service.proto",
}

// PolicyStoreClient is the client API for PolicyStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PolicyStoreClient interface {
	Handshake(ctx context.Context, in *Node, opts ...grpc.CallOption) (*HandshakeResponse, error)
}

type policyStoreClient struct {
	cc *grpc.ClientConn
}

func NewPolicyStoreClient(cc *grpc.ClientConn) PolicyStoreClient {
	return &policyStoreClient{cc}
}

func (c *policyStoreClient) Handshake(ctx context.Context, in *Node, opts ...grpc.CallOption) (*HandshakeResponse, error) {
	out := new(HandshakeResponse)
	err := c.cc.Invoke(ctx, "/proto.PolicyStore/Handshake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PolicyStoreServer is the server API for PolicyStore service.
type PolicyStoreServer interface {
	Handshake(context.Context, *Node) (*HandshakeResponse, error)
}

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

func (*UnimplementedPolicyStoreServer) Handshake(ctx context.Context, req *Node) (*HandshakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Handshake not implemented")
}

func RegisterPolicyStoreServer(s *grpc.Server, srv PolicyStoreServer) {
	s.RegisterService(&_PolicyStore_serviceDesc, srv)
}

func _PolicyStore_Handshake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Node)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PolicyStoreServer).Handshake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.PolicyStore/Handshake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PolicyStoreServer).Handshake(ctx, req.(*Node))
	}
	return interceptor(ctx, in, info, handler)
}

var _PolicyStore_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.PolicyStore",
	HandlerType: (*PolicyStoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Handshake",
			Handler:    _PolicyStore_Handshake_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service.proto",
}