// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        (unknown)
// source: orlysync/negentropy/v1/service.proto

package negentropyv1

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	v1 "next.orly.dev/pkg/proto/orlysync/common/v1"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// NegOpenRequest processes a NEG-OPEN from client
// NEG-OPEN format: ["NEG-OPEN", subscription_id, filter, initial_message?]
type NegOpenRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SubscriptionId string                 `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"` // Client's subscription ID
	Filter         *v1.Filter             `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`                                       // Nostr filter for reconciliation
	InitialMessage []byte                 `protobuf:"bytes,3,opt,name=initial_message,json=initialMessage,proto3" json:"initial_message,omitempty"` // Optional initial negentropy message
	ConnectionId   string                 `protobuf:"bytes,4,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`       // Connection ID for session tracking
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *NegOpenRequest) Reset() {
	*x = NegOpenRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NegOpenRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NegOpenRequest) ProtoMessage() {}

func (x *NegOpenRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NegOpenRequest.ProtoReflect.Descriptor instead.
func (*NegOpenRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{0}
}

func (x *NegOpenRequest) GetSubscriptionId() string {
	if x != nil {
		return x.SubscriptionId
	}
	return ""
}

func (x *NegOpenRequest) GetFilter() *v1.Filter {
	if x != nil {
		return x.Filter
	}
	return nil
}

func (x *NegOpenRequest) GetInitialMessage() []byte {
	if x != nil {
		return x.InitialMessage
	}
	return nil
}

func (x *NegOpenRequest) GetConnectionId() string {
	if x != nil {
		return x.ConnectionId
	}
	return ""
}

// NegOpenResponse returns the initial negentropy response
type NegOpenResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       []byte                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`                // Negentropy protocol message to send back
	HaveIds       [][]byte               `protobuf:"bytes,2,rep,name=have_ids,json=haveIds,proto3" json:"have_ids,omitempty"` // Event IDs we have that client needs (if initial reconciliation completes)
	NeedIds       [][]byte               `protobuf:"bytes,3,rep,name=need_ids,json=needIds,proto3" json:"need_ids,omitempty"` // Event IDs we need from client (if initial reconciliation completes)
	Complete      bool                   `protobuf:"varint,4,opt,name=complete,proto3" json:"complete,omitempty"`             // True if reconciliation completed in first round
	Error         string                 `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`                    // Error message if failed
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NegOpenResponse) Reset() {
	*x = NegOpenResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NegOpenResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NegOpenResponse) ProtoMessage() {}

func (x *NegOpenResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NegOpenResponse.ProtoReflect.Descriptor instead.
func (*NegOpenResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{1}
}

func (x *NegOpenResponse) GetMessage() []byte {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *NegOpenResponse) GetHaveIds() [][]byte {
	if x != nil {
		return x.HaveIds
	}
	return nil
}

func (x *NegOpenResponse) GetNeedIds() [][]byte {
	if x != nil {
		return x.NeedIds
	}
	return nil
}

func (x *NegOpenResponse) GetComplete() bool {
	if x != nil {
		return x.Complete
	}
	return false
}

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

// NegMsgRequest processes a NEG-MSG from client
// NEG-MSG format: ["NEG-MSG", subscription_id, message]
type NegMsgRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SubscriptionId string                 `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
	Message        []byte                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` // Negentropy protocol message
	ConnectionId   string                 `protobuf:"bytes,3,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *NegMsgRequest) Reset() {
	*x = NegMsgRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NegMsgRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NegMsgRequest) ProtoMessage() {}

func (x *NegMsgRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NegMsgRequest.ProtoReflect.Descriptor instead.
func (*NegMsgRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{2}
}

func (x *NegMsgRequest) GetSubscriptionId() string {
	if x != nil {
		return x.SubscriptionId
	}
	return ""
}

func (x *NegMsgRequest) GetMessage() []byte {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *NegMsgRequest) GetConnectionId() string {
	if x != nil {
		return x.ConnectionId
	}
	return ""
}

// NegMsgResponse returns reconciliation results
type NegMsgResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       []byte                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`                // Negentropy protocol message to send back
	HaveIds       [][]byte               `protobuf:"bytes,2,rep,name=have_ids,json=haveIds,proto3" json:"have_ids,omitempty"` // Event IDs we have that client needs
	NeedIds       [][]byte               `protobuf:"bytes,3,rep,name=need_ids,json=needIds,proto3" json:"need_ids,omitempty"` // Event IDs we need from client
	Complete      bool                   `protobuf:"varint,4,opt,name=complete,proto3" json:"complete,omitempty"`             // True if reconciliation is complete
	Error         string                 `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`                    // Error message if failed
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NegMsgResponse) Reset() {
	*x = NegMsgResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NegMsgResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NegMsgResponse) ProtoMessage() {}

func (x *NegMsgResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NegMsgResponse.ProtoReflect.Descriptor instead.
func (*NegMsgResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{3}
}

func (x *NegMsgResponse) GetMessage() []byte {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *NegMsgResponse) GetHaveIds() [][]byte {
	if x != nil {
		return x.HaveIds
	}
	return nil
}

func (x *NegMsgResponse) GetNeedIds() [][]byte {
	if x != nil {
		return x.NeedIds
	}
	return nil
}

func (x *NegMsgResponse) GetComplete() bool {
	if x != nil {
		return x.Complete
	}
	return false
}

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

// NegCloseRequest processes a NEG-CLOSE from client
// NEG-CLOSE format: ["NEG-CLOSE", subscription_id]
type NegCloseRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SubscriptionId string                 `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
	ConnectionId   string                 `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *NegCloseRequest) Reset() {
	*x = NegCloseRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NegCloseRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NegCloseRequest) ProtoMessage() {}

func (x *NegCloseRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NegCloseRequest.ProtoReflect.Descriptor instead.
func (*NegCloseRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{4}
}

func (x *NegCloseRequest) GetSubscriptionId() string {
	if x != nil {
		return x.SubscriptionId
	}
	return ""
}

func (x *NegCloseRequest) GetConnectionId() string {
	if x != nil {
		return x.ConnectionId
	}
	return ""
}

// SyncPeerRequest initiates sync with a peer
type SyncPeerRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"` // WebSocket URL of peer relay
	Filter        *v1.Filter             `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`                  // Optional filter to limit sync scope
	Since         int64                  `protobuf:"varint,3,opt,name=since,proto3" json:"since,omitempty"`                   // Optional: only sync events since timestamp
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SyncPeerRequest) Reset() {
	*x = SyncPeerRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SyncPeerRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SyncPeerRequest) ProtoMessage() {}

func (x *SyncPeerRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SyncPeerRequest.ProtoReflect.Descriptor instead.
func (*SyncPeerRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{5}
}

func (x *SyncPeerRequest) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

func (x *SyncPeerRequest) GetFilter() *v1.Filter {
	if x != nil {
		return x.Filter
	}
	return nil
}

func (x *SyncPeerRequest) GetSince() int64 {
	if x != nil {
		return x.Since
	}
	return 0
}

// SyncProgress streams sync progress updates
type SyncProgress struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"`
	Round         int32                  `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`                                   // Reconciliation round number
	HaveCount     int64                  `protobuf:"varint,3,opt,name=have_count,json=haveCount,proto3" json:"have_count,omitempty"`          // Events we have that peer needs
	NeedCount     int64                  `protobuf:"varint,4,opt,name=need_count,json=needCount,proto3" json:"need_count,omitempty"`          // Events we need from peer
	FetchedCount  int64                  `protobuf:"varint,5,opt,name=fetched_count,json=fetchedCount,proto3" json:"fetched_count,omitempty"` // Events fetched so far
	SentCount     int64                  `protobuf:"varint,6,opt,name=sent_count,json=sentCount,proto3" json:"sent_count,omitempty"`          // Events sent so far
	Complete      bool                   `protobuf:"varint,7,opt,name=complete,proto3" json:"complete,omitempty"`                             // True when sync is complete
	Error         string                 `protobuf:"bytes,8,opt,name=error,proto3" json:"error,omitempty"`                                    // Error message if failed
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SyncProgress) Reset() {
	*x = SyncProgress{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SyncProgress) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SyncProgress) ProtoMessage() {}

func (x *SyncProgress) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SyncProgress.ProtoReflect.Descriptor instead.
func (*SyncProgress) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{6}
}

func (x *SyncProgress) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

func (x *SyncProgress) GetRound() int32 {
	if x != nil {
		return x.Round
	}
	return 0
}

func (x *SyncProgress) GetHaveCount() int64 {
	if x != nil {
		return x.HaveCount
	}
	return 0
}

func (x *SyncProgress) GetNeedCount() int64 {
	if x != nil {
		return x.NeedCount
	}
	return 0
}

func (x *SyncProgress) GetFetchedCount() int64 {
	if x != nil {
		return x.FetchedCount
	}
	return 0
}

func (x *SyncProgress) GetSentCount() int64 {
	if x != nil {
		return x.SentCount
	}
	return 0
}

func (x *SyncProgress) GetComplete() bool {
	if x != nil {
		return x.Complete
	}
	return false
}

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

// SyncStatusResponse contains overall sync status
type SyncStatusResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Active        bool                   `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"`                     // Whether background sync is running
	LastSync      int64                  `protobuf:"varint,2,opt,name=last_sync,json=lastSync,proto3" json:"last_sync,omitempty"` // Timestamp of last sync
	PeerCount     int32                  `protobuf:"varint,3,opt,name=peer_count,json=peerCount,proto3" json:"peer_count,omitempty"`
	PeerStates    []*PeerSyncState       `protobuf:"bytes,4,rep,name=peer_states,json=peerStates,proto3" json:"peer_states,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SyncStatusResponse) Reset() {
	*x = SyncStatusResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SyncStatusResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SyncStatusResponse) ProtoMessage() {}

func (x *SyncStatusResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SyncStatusResponse.ProtoReflect.Descriptor instead.
func (*SyncStatusResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{7}
}

func (x *SyncStatusResponse) GetActive() bool {
	if x != nil {
		return x.Active
	}
	return false
}

func (x *SyncStatusResponse) GetLastSync() int64 {
	if x != nil {
		return x.LastSync
	}
	return 0
}

func (x *SyncStatusResponse) GetPeerCount() int32 {
	if x != nil {
		return x.PeerCount
	}
	return 0
}

func (x *SyncStatusResponse) GetPeerStates() []*PeerSyncState {
	if x != nil {
		return x.PeerStates
	}
	return nil
}

// PeersResponse contains the list of peers
type PeersResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Peers         []string               `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` // List of peer WebSocket URLs
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PeersResponse) Reset() {
	*x = PeersResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeersResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeersResponse) ProtoMessage() {}

func (x *PeersResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PeersResponse.ProtoReflect.Descriptor instead.
func (*PeersResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{8}
}

func (x *PeersResponse) GetPeers() []string {
	if x != nil {
		return x.Peers
	}
	return nil
}

// AddPeerRequest adds a peer
type AddPeerRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddPeerRequest) Reset() {
	*x = AddPeerRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddPeerRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddPeerRequest) ProtoMessage() {}

func (x *AddPeerRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddPeerRequest.ProtoReflect.Descriptor instead.
func (*AddPeerRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{9}
}

func (x *AddPeerRequest) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

// RemovePeerRequest removes a peer
type RemovePeerRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RemovePeerRequest) Reset() {
	*x = RemovePeerRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RemovePeerRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RemovePeerRequest) ProtoMessage() {}

func (x *RemovePeerRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RemovePeerRequest.ProtoReflect.Descriptor instead.
func (*RemovePeerRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{10}
}

func (x *RemovePeerRequest) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

// TriggerSyncRequest triggers manual sync
type TriggerSyncRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"` // Optional: specific peer (empty = all)
	Filter        *v1.Filter             `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`                  // Optional: filter for sync scope
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TriggerSyncRequest) Reset() {
	*x = TriggerSyncRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TriggerSyncRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TriggerSyncRequest) ProtoMessage() {}

func (x *TriggerSyncRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TriggerSyncRequest.ProtoReflect.Descriptor instead.
func (*TriggerSyncRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{11}
}

func (x *TriggerSyncRequest) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

func (x *TriggerSyncRequest) GetFilter() *v1.Filter {
	if x != nil {
		return x.Filter
	}
	return nil
}

// PeerSyncStateRequest requests state for a peer
type PeerSyncStateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl       string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PeerSyncStateRequest) Reset() {
	*x = PeerSyncStateRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeerSyncStateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerSyncStateRequest) ProtoMessage() {}

func (x *PeerSyncStateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PeerSyncStateRequest.ProtoReflect.Descriptor instead.
func (*PeerSyncStateRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{12}
}

func (x *PeerSyncStateRequest) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

// PeerSyncStateResponse contains peer sync state
type PeerSyncStateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	State         *PeerSyncState         `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Found         bool                   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PeerSyncStateResponse) Reset() {
	*x = PeerSyncStateResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeerSyncStateResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerSyncStateResponse) ProtoMessage() {}

func (x *PeerSyncStateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PeerSyncStateResponse.ProtoReflect.Descriptor instead.
func (*PeerSyncStateResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{13}
}

func (x *PeerSyncStateResponse) GetState() *PeerSyncState {
	if x != nil {
		return x.State
	}
	return nil
}

func (x *PeerSyncStateResponse) GetFound() bool {
	if x != nil {
		return x.Found
	}
	return false
}

// PeerSyncState represents sync state for a peer
type PeerSyncState struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	PeerUrl             string                 `protobuf:"bytes,1,opt,name=peer_url,json=peerUrl,proto3" json:"peer_url,omitempty"`
	LastSync            int64                  `protobuf:"varint,2,opt,name=last_sync,json=lastSync,proto3" json:"last_sync,omitempty"`             // Timestamp of last successful sync
	EventsSynced        int64                  `protobuf:"varint,3,opt,name=events_synced,json=eventsSynced,proto3" json:"events_synced,omitempty"` // Total events synced from this peer
	Status              string                 `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`                                  // "idle", "syncing", "error"
	LastError           string                 `protobuf:"bytes,5,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"`           // Last error message
	ConsecutiveFailures int32                  `protobuf:"varint,6,opt,name=consecutive_failures,json=consecutiveFailures,proto3" json:"consecutive_failures,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *PeerSyncState) Reset() {
	*x = PeerSyncState{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeerSyncState) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerSyncState) ProtoMessage() {}

func (x *PeerSyncState) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PeerSyncState.ProtoReflect.Descriptor instead.
func (*PeerSyncState) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{14}
}

func (x *PeerSyncState) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

func (x *PeerSyncState) GetLastSync() int64 {
	if x != nil {
		return x.LastSync
	}
	return 0
}

func (x *PeerSyncState) GetEventsSynced() int64 {
	if x != nil {
		return x.EventsSynced
	}
	return 0
}

func (x *PeerSyncState) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

func (x *PeerSyncState) GetLastError() string {
	if x != nil {
		return x.LastError
	}
	return ""
}

func (x *PeerSyncState) GetConsecutiveFailures() int32 {
	if x != nil {
		return x.ConsecutiveFailures
	}
	return 0
}

// ClientSession represents an active client negentropy session
type ClientSession struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SubscriptionId string                 `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
	ConnectionId   string                 `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	CreatedAt      int64                  `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	LastActivity   int64                  `protobuf:"varint,4,opt,name=last_activity,json=lastActivity,proto3" json:"last_activity,omitempty"`
	RoundCount     int32                  `protobuf:"varint,5,opt,name=round_count,json=roundCount,proto3" json:"round_count,omitempty"` // Number of reconciliation rounds
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *ClientSession) Reset() {
	*x = ClientSession{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ClientSession) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ClientSession) ProtoMessage() {}

func (x *ClientSession) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ClientSession.ProtoReflect.Descriptor instead.
func (*ClientSession) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{15}
}

func (x *ClientSession) GetSubscriptionId() string {
	if x != nil {
		return x.SubscriptionId
	}
	return ""
}

func (x *ClientSession) GetConnectionId() string {
	if x != nil {
		return x.ConnectionId
	}
	return ""
}

func (x *ClientSession) GetCreatedAt() int64 {
	if x != nil {
		return x.CreatedAt
	}
	return 0
}

func (x *ClientSession) GetLastActivity() int64 {
	if x != nil {
		return x.LastActivity
	}
	return 0
}

func (x *ClientSession) GetRoundCount() int32 {
	if x != nil {
		return x.RoundCount
	}
	return 0
}

// ListSessionsResponse contains active sessions
type ListSessionsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Sessions      []*ClientSession       `protobuf:"bytes,1,rep,name=sessions,proto3" json:"sessions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListSessionsResponse) Reset() {
	*x = ListSessionsResponse{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListSessionsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListSessionsResponse) ProtoMessage() {}

func (x *ListSessionsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListSessionsResponse.ProtoReflect.Descriptor instead.
func (*ListSessionsResponse) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{16}
}

func (x *ListSessionsResponse) GetSessions() []*ClientSession {
	if x != nil {
		return x.Sessions
	}
	return nil
}

// CloseSessionRequest closes a session
type CloseSessionRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SubscriptionId string                 `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
	ConnectionId   string                 `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"` // Optional: if empty, close all with this sub_id
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *CloseSessionRequest) Reset() {
	*x = CloseSessionRequest{}
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CloseSessionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CloseSessionRequest) ProtoMessage() {}

func (x *CloseSessionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_orlysync_negentropy_v1_service_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CloseSessionRequest.ProtoReflect.Descriptor instead.
func (*CloseSessionRequest) Descriptor() ([]byte, []int) {
	return file_orlysync_negentropy_v1_service_proto_rawDescGZIP(), []int{17}
}

func (x *CloseSessionRequest) GetSubscriptionId() string {
	if x != nil {
		return x.SubscriptionId
	}
	return ""
}

func (x *CloseSessionRequest) GetConnectionId() string {
	if x != nil {
		return x.ConnectionId
	}
	return ""
}

var File_orlysync_negentropy_v1_service_proto protoreflect.FileDescriptor

const file_orlysync_negentropy_v1_service_proto_rawDesc = "" +
	"\n" +
	"$orlysync/negentropy/v1/service.proto\x12\x16orlysync.negentropy.v1\x1a\x1eorlysync/common/v1/types.proto\"\xbb\x01\n" +
	"\x0eNegOpenRequest\x12'\n" +
	"\x0fsubscription_id\x18\x01 \x01(\tR\x0esubscriptionId\x122\n" +
	"\x06filter\x18\x02 \x01(\v2\x1a.orlysync.common.v1.FilterR\x06filter\x12'\n" +
	"\x0finitial_message\x18\x03 \x01(\fR\x0einitialMessage\x12#\n" +
	"\rconnection_id\x18\x04 \x01(\tR\fconnectionId\"\x93\x01\n" +
	"\x0fNegOpenResponse\x12\x18\n" +
	"\amessage\x18\x01 \x01(\fR\amessage\x12\x19\n" +
	"\bhave_ids\x18\x02 \x03(\fR\ahaveIds\x12\x19\n" +
	"\bneed_ids\x18\x03 \x03(\fR\aneedIds\x12\x1a\n" +
	"\bcomplete\x18\x04 \x01(\bR\bcomplete\x12\x14\n" +
	"\x05error\x18\x05 \x01(\tR\x05error\"w\n" +
	"\rNegMsgRequest\x12'\n" +
	"\x0fsubscription_id\x18\x01 \x01(\tR\x0esubscriptionId\x12\x18\n" +
	"\amessage\x18\x02 \x01(\fR\amessage\x12#\n" +
	"\rconnection_id\x18\x03 \x01(\tR\fconnectionId\"\x92\x01\n" +
	"\x0eNegMsgResponse\x12\x18\n" +
	"\amessage\x18\x01 \x01(\fR\amessage\x12\x19\n" +
	"\bhave_ids\x18\x02 \x03(\fR\ahaveIds\x12\x19\n" +
	"\bneed_ids\x18\x03 \x03(\fR\aneedIds\x12\x1a\n" +
	"\bcomplete\x18\x04 \x01(\bR\bcomplete\x12\x14\n" +
	"\x05error\x18\x05 \x01(\tR\x05error\"_\n" +
	"\x0fNegCloseRequest\x12'\n" +
	"\x0fsubscription_id\x18\x01 \x01(\tR\x0esubscriptionId\x12#\n" +
	"\rconnection_id\x18\x02 \x01(\tR\fconnectionId\"v\n" +
	"\x0fSyncPeerRequest\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\x122\n" +
	"\x06filter\x18\x02 \x01(\v2\x1a.orlysync.common.v1.FilterR\x06filter\x12\x14\n" +
	"\x05since\x18\x03 \x01(\x03R\x05since\"\xf3\x01\n" +
	"\fSyncProgress\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\x12\x14\n" +
	"\x05round\x18\x02 \x01(\x05R\x05round\x12\x1d\n" +
	"\n" +
	"have_count\x18\x03 \x01(\x03R\thaveCount\x12\x1d\n" +
	"\n" +
	"need_count\x18\x04 \x01(\x03R\tneedCount\x12#\n" +
	"\rfetched_count\x18\x05 \x01(\x03R\ffetchedCount\x12\x1d\n" +
	"\n" +
	"sent_count\x18\x06 \x01(\x03R\tsentCount\x12\x1a\n" +
	"\bcomplete\x18\a \x01(\bR\bcomplete\x12\x14\n" +
	"\x05error\x18\b \x01(\tR\x05error\"\xb0\x01\n" +
	"\x12SyncStatusResponse\x12\x16\n" +
	"\x06active\x18\x01 \x01(\bR\x06active\x12\x1b\n" +
	"\tlast_sync\x18\x02 \x01(\x03R\blastSync\x12\x1d\n" +
	"\n" +
	"peer_count\x18\x03 \x01(\x05R\tpeerCount\x12F\n" +
	"\vpeer_states\x18\x04 \x03(\v2%.orlysync.negentropy.v1.PeerSyncStateR\n" +
	"peerStates\"%\n" +
	"\rPeersResponse\x12\x14\n" +
	"\x05peers\x18\x01 \x03(\tR\x05peers\"+\n" +
	"\x0eAddPeerRequest\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\".\n" +
	"\x11RemovePeerRequest\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\"c\n" +
	"\x12TriggerSyncRequest\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\x122\n" +
	"\x06filter\x18\x02 \x01(\v2\x1a.orlysync.common.v1.FilterR\x06filter\"1\n" +
	"\x14PeerSyncStateRequest\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\"j\n" +
	"\x15PeerSyncStateResponse\x12;\n" +
	"\x05state\x18\x01 \x01(\v2%.orlysync.negentropy.v1.PeerSyncStateR\x05state\x12\x14\n" +
	"\x05found\x18\x02 \x01(\bR\x05found\"\xd6\x01\n" +
	"\rPeerSyncState\x12\x19\n" +
	"\bpeer_url\x18\x01 \x01(\tR\apeerUrl\x12\x1b\n" +
	"\tlast_sync\x18\x02 \x01(\x03R\blastSync\x12#\n" +
	"\revents_synced\x18\x03 \x01(\x03R\feventsSynced\x12\x16\n" +
	"\x06status\x18\x04 \x01(\tR\x06status\x12\x1d\n" +
	"\n" +
	"last_error\x18\x05 \x01(\tR\tlastError\x121\n" +
	"\x14consecutive_failures\x18\x06 \x01(\x05R\x13consecutiveFailures\"\xc2\x01\n" +
	"\rClientSession\x12'\n" +
	"\x0fsubscription_id\x18\x01 \x01(\tR\x0esubscriptionId\x12#\n" +
	"\rconnection_id\x18\x02 \x01(\tR\fconnectionId\x12\x1d\n" +
	"\n" +
	"created_at\x18\x03 \x01(\x03R\tcreatedAt\x12#\n" +
	"\rlast_activity\x18\x04 \x01(\x03R\flastActivity\x12\x1f\n" +
	"\vround_count\x18\x05 \x01(\x05R\n" +
	"roundCount\"Y\n" +
	"\x14ListSessionsResponse\x12A\n" +
	"\bsessions\x18\x01 \x03(\v2%.orlysync.negentropy.v1.ClientSessionR\bsessions\"c\n" +
	"\x13CloseSessionRequest\x12'\n" +
	"\x0fsubscription_id\x18\x01 \x01(\tR\x0esubscriptionId\x12#\n" +
	"\rconnection_id\x18\x02 \x01(\tR\fconnectionId2\x8f\n" +
	"\n" +
	"\x11NegentropyService\x12E\n" +
	"\x05Ready\x12\x19.orlysync.common.v1.Empty\x1a!.orlysync.common.v1.ReadyResponse\x12=\n" +
	"\x05Start\x12\x19.orlysync.common.v1.Empty\x1a\x19.orlysync.common.v1.Empty\x12<\n" +
	"\x04Stop\x12\x19.orlysync.common.v1.Empty\x1a\x19.orlysync.common.v1.Empty\x12`\n" +
	"\rHandleNegOpen\x12&.orlysync.negentropy.v1.NegOpenRequest\x1a'.orlysync.negentropy.v1.NegOpenResponse\x12]\n" +
	"\fHandleNegMsg\x12%.orlysync.negentropy.v1.NegMsgRequest\x1a&.orlysync.negentropy.v1.NegMsgResponse\x12T\n" +
	"\x0eHandleNegClose\x12'.orlysync.negentropy.v1.NegCloseRequest\x1a\x19.orlysync.common.v1.Empty\x12_\n" +
	"\fSyncWithPeer\x12'.orlysync.negentropy.v1.SyncPeerRequest\x1a$.orlysync.negentropy.v1.SyncProgress0\x01\x12V\n" +
	"\rGetSyncStatus\x12\x19.orlysync.common.v1.Empty\x1a*.orlysync.negentropy.v1.SyncStatusResponse\x12L\n" +
	"\bGetPeers\x12\x19.orlysync.common.v1.Empty\x1a%.orlysync.negentropy.v1.PeersResponse\x12L\n" +
	"\aAddPeer\x12&.orlysync.negentropy.v1.AddPeerRequest\x1a\x19.orlysync.common.v1.Empty\x12R\n" +
	"\n" +
	"RemovePeer\x12).orlysync.negentropy.v1.RemovePeerRequest\x1a\x19.orlysync.common.v1.Empty\x12T\n" +
	"\vTriggerSync\x12*.orlysync.negentropy.v1.TriggerSyncRequest\x1a\x19.orlysync.common.v1.Empty\x12o\n" +
	"\x10GetPeerSyncState\x12,.orlysync.negentropy.v1.PeerSyncStateRequest\x1a-.orlysync.negentropy.v1.PeerSyncStateResponse\x12W\n" +
	"\fListSessions\x12\x19.orlysync.common.v1.Empty\x1a,.orlysync.negentropy.v1.ListSessionsResponse\x12V\n" +
	"\fCloseSession\x12+.orlysync.negentropy.v1.CloseSessionRequest\x1a\x19.orlysync.common.v1.EmptyB=Z;next.orly.dev/pkg/proto/orlysync/negentropy/v1;negentropyv1b\x06proto3"

var (
	file_orlysync_negentropy_v1_service_proto_rawDescOnce sync.Once
	file_orlysync_negentropy_v1_service_proto_rawDescData []byte
)

func file_orlysync_negentropy_v1_service_proto_rawDescGZIP() []byte {
	file_orlysync_negentropy_v1_service_proto_rawDescOnce.Do(func() {
		file_orlysync_negentropy_v1_service_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_orlysync_negentropy_v1_service_proto_rawDesc), len(file_orlysync_negentropy_v1_service_proto_rawDesc)))
	})
	return file_orlysync_negentropy_v1_service_proto_rawDescData
}

var file_orlysync_negentropy_v1_service_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
var file_orlysync_negentropy_v1_service_proto_goTypes = []any{
	(*NegOpenRequest)(nil),        // 0: orlysync.negentropy.v1.NegOpenRequest
	(*NegOpenResponse)(nil),       // 1: orlysync.negentropy.v1.NegOpenResponse
	(*NegMsgRequest)(nil),         // 2: orlysync.negentropy.v1.NegMsgRequest
	(*NegMsgResponse)(nil),        // 3: orlysync.negentropy.v1.NegMsgResponse
	(*NegCloseRequest)(nil),       // 4: orlysync.negentropy.v1.NegCloseRequest
	(*SyncPeerRequest)(nil),       // 5: orlysync.negentropy.v1.SyncPeerRequest
	(*SyncProgress)(nil),          // 6: orlysync.negentropy.v1.SyncProgress
	(*SyncStatusResponse)(nil),    // 7: orlysync.negentropy.v1.SyncStatusResponse
	(*PeersResponse)(nil),         // 8: orlysync.negentropy.v1.PeersResponse
	(*AddPeerRequest)(nil),        // 9: orlysync.negentropy.v1.AddPeerRequest
	(*RemovePeerRequest)(nil),     // 10: orlysync.negentropy.v1.RemovePeerRequest
	(*TriggerSyncRequest)(nil),    // 11: orlysync.negentropy.v1.TriggerSyncRequest
	(*PeerSyncStateRequest)(nil),  // 12: orlysync.negentropy.v1.PeerSyncStateRequest
	(*PeerSyncStateResponse)(nil), // 13: orlysync.negentropy.v1.PeerSyncStateResponse
	(*PeerSyncState)(nil),         // 14: orlysync.negentropy.v1.PeerSyncState
	(*ClientSession)(nil),         // 15: orlysync.negentropy.v1.ClientSession
	(*ListSessionsResponse)(nil),  // 16: orlysync.negentropy.v1.ListSessionsResponse
	(*CloseSessionRequest)(nil),   // 17: orlysync.negentropy.v1.CloseSessionRequest
	(*v1.Filter)(nil),             // 18: orlysync.common.v1.Filter
	(*v1.Empty)(nil),              // 19: orlysync.common.v1.Empty
	(*v1.ReadyResponse)(nil),      // 20: orlysync.common.v1.ReadyResponse
}
var file_orlysync_negentropy_v1_service_proto_depIdxs = []int32{
	18, // 0: orlysync.negentropy.v1.NegOpenRequest.filter:type_name -> orlysync.common.v1.Filter
	18, // 1: orlysync.negentropy.v1.SyncPeerRequest.filter:type_name -> orlysync.common.v1.Filter
	14, // 2: orlysync.negentropy.v1.SyncStatusResponse.peer_states:type_name -> orlysync.negentropy.v1.PeerSyncState
	18, // 3: orlysync.negentropy.v1.TriggerSyncRequest.filter:type_name -> orlysync.common.v1.Filter
	14, // 4: orlysync.negentropy.v1.PeerSyncStateResponse.state:type_name -> orlysync.negentropy.v1.PeerSyncState
	15, // 5: orlysync.negentropy.v1.ListSessionsResponse.sessions:type_name -> orlysync.negentropy.v1.ClientSession
	19, // 6: orlysync.negentropy.v1.NegentropyService.Ready:input_type -> orlysync.common.v1.Empty
	19, // 7: orlysync.negentropy.v1.NegentropyService.Start:input_type -> orlysync.common.v1.Empty
	19, // 8: orlysync.negentropy.v1.NegentropyService.Stop:input_type -> orlysync.common.v1.Empty
	0,  // 9: orlysync.negentropy.v1.NegentropyService.HandleNegOpen:input_type -> orlysync.negentropy.v1.NegOpenRequest
	2,  // 10: orlysync.negentropy.v1.NegentropyService.HandleNegMsg:input_type -> orlysync.negentropy.v1.NegMsgRequest
	4,  // 11: orlysync.negentropy.v1.NegentropyService.HandleNegClose:input_type -> orlysync.negentropy.v1.NegCloseRequest
	5,  // 12: orlysync.negentropy.v1.NegentropyService.SyncWithPeer:input_type -> orlysync.negentropy.v1.SyncPeerRequest
	19, // 13: orlysync.negentropy.v1.NegentropyService.GetSyncStatus:input_type -> orlysync.common.v1.Empty
	19, // 14: orlysync.negentropy.v1.NegentropyService.GetPeers:input_type -> orlysync.common.v1.Empty
	9,  // 15: orlysync.negentropy.v1.NegentropyService.AddPeer:input_type -> orlysync.negentropy.v1.AddPeerRequest
	10, // 16: orlysync.negentropy.v1.NegentropyService.RemovePeer:input_type -> orlysync.negentropy.v1.RemovePeerRequest
	11, // 17: orlysync.negentropy.v1.NegentropyService.TriggerSync:input_type -> orlysync.negentropy.v1.TriggerSyncRequest
	12, // 18: orlysync.negentropy.v1.NegentropyService.GetPeerSyncState:input_type -> orlysync.negentropy.v1.PeerSyncStateRequest
	19, // 19: orlysync.negentropy.v1.NegentropyService.ListSessions:input_type -> orlysync.common.v1.Empty
	17, // 20: orlysync.negentropy.v1.NegentropyService.CloseSession:input_type -> orlysync.negentropy.v1.CloseSessionRequest
	20, // 21: orlysync.negentropy.v1.NegentropyService.Ready:output_type -> orlysync.common.v1.ReadyResponse
	19, // 22: orlysync.negentropy.v1.NegentropyService.Start:output_type -> orlysync.common.v1.Empty
	19, // 23: orlysync.negentropy.v1.NegentropyService.Stop:output_type -> orlysync.common.v1.Empty
	1,  // 24: orlysync.negentropy.v1.NegentropyService.HandleNegOpen:output_type -> orlysync.negentropy.v1.NegOpenResponse
	3,  // 25: orlysync.negentropy.v1.NegentropyService.HandleNegMsg:output_type -> orlysync.negentropy.v1.NegMsgResponse
	19, // 26: orlysync.negentropy.v1.NegentropyService.HandleNegClose:output_type -> orlysync.common.v1.Empty
	6,  // 27: orlysync.negentropy.v1.NegentropyService.SyncWithPeer:output_type -> orlysync.negentropy.v1.SyncProgress
	7,  // 28: orlysync.negentropy.v1.NegentropyService.GetSyncStatus:output_type -> orlysync.negentropy.v1.SyncStatusResponse
	8,  // 29: orlysync.negentropy.v1.NegentropyService.GetPeers:output_type -> orlysync.negentropy.v1.PeersResponse
	19, // 30: orlysync.negentropy.v1.NegentropyService.AddPeer:output_type -> orlysync.common.v1.Empty
	19, // 31: orlysync.negentropy.v1.NegentropyService.RemovePeer:output_type -> orlysync.common.v1.Empty
	19, // 32: orlysync.negentropy.v1.NegentropyService.TriggerSync:output_type -> orlysync.common.v1.Empty
	13, // 33: orlysync.negentropy.v1.NegentropyService.GetPeerSyncState:output_type -> orlysync.negentropy.v1.PeerSyncStateResponse
	16, // 34: orlysync.negentropy.v1.NegentropyService.ListSessions:output_type -> orlysync.negentropy.v1.ListSessionsResponse
	19, // 35: orlysync.negentropy.v1.NegentropyService.CloseSession:output_type -> orlysync.common.v1.Empty
	21, // [21:36] is the sub-list for method output_type
	6,  // [6:21] is the sub-list for method input_type
	6,  // [6:6] is the sub-list for extension type_name
	6,  // [6:6] is the sub-list for extension extendee
	0,  // [0:6] is the sub-list for field type_name
}

func init() { file_orlysync_negentropy_v1_service_proto_init() }
func file_orlysync_negentropy_v1_service_proto_init() {
	if File_orlysync_negentropy_v1_service_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_orlysync_negentropy_v1_service_proto_rawDesc), len(file_orlysync_negentropy_v1_service_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   18,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_orlysync_negentropy_v1_service_proto_goTypes,
		DependencyIndexes: file_orlysync_negentropy_v1_service_proto_depIdxs,
		MessageInfos:      file_orlysync_negentropy_v1_service_proto_msgTypes,
	}.Build()
	File_orlysync_negentropy_v1_service_proto = out.File
	file_orlysync_negentropy_v1_service_proto_goTypes = nil
	file_orlysync_negentropy_v1_service_proto_depIdxs = nil
}