d-engine-proto 0.2.3

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.0
// source: proto/common.proto

package common

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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)
)

type NodeStatus int32

const (
	// Zero value: unspecified/default state (buf lint: ENUM_ZERO_VALUE_SUFFIX)
	// Nodes in this state should explicitly set their status before joining cluster
	NodeStatus_NODE_STATUS_UNSPECIFIED NodeStatus = 0
	// Learner states
	NodeStatus_NODE_STATUS_PROMOTABLE NodeStatus = 1 // Learner that CAN be promoted to voter
	NodeStatus_NODE_STATUS_READ_ONLY  NodeStatus = 2 // Learner that will NEVER be promoted (permanent analytics node)
	// Voter state
	NodeStatus_NODE_STATUS_ACTIVE NodeStatus = 3 // Voting member (Follower, Candidate, or Leader)
)

// Enum value maps for NodeStatus.
var (
	NodeStatus_name = map[int32]string{
		0: "NODE_STATUS_UNSPECIFIED",
		1: "NODE_STATUS_PROMOTABLE",
		2: "NODE_STATUS_READ_ONLY",
		3: "NODE_STATUS_ACTIVE",
	}
	NodeStatus_value = map[string]int32{
		"NODE_STATUS_UNSPECIFIED": 0,
		"NODE_STATUS_PROMOTABLE":  1,
		"NODE_STATUS_READ_ONLY":   2,
		"NODE_STATUS_ACTIVE":      3,
	}
)

func (x NodeStatus) Enum() *NodeStatus {
	p := new(NodeStatus)
	*p = x
	return p
}

func (x NodeStatus) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (NodeStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_common_proto_enumTypes[0].Descriptor()
}

func (NodeStatus) Type() protoreflect.EnumType {
	return &file_proto_common_proto_enumTypes[0]
}

func (x NodeStatus) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use NodeStatus.Descriptor instead.
func (NodeStatus) EnumDescriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{0}
}

type NodeRole int32

const (
	NodeRole_NODE_ROLE_UNSPECIFIED NodeRole = 0
	NodeRole_NODE_ROLE_FOLLOWER    NodeRole = 1
	NodeRole_NODE_ROLE_CANDIDATE   NodeRole = 2
	NodeRole_NODE_ROLE_LEADER      NodeRole = 3
	NodeRole_NODE_ROLE_LEARNER     NodeRole = 4
)

// Enum value maps for NodeRole.
var (
	NodeRole_name = map[int32]string{
		0: "NODE_ROLE_UNSPECIFIED",
		1: "NODE_ROLE_FOLLOWER",
		2: "NODE_ROLE_CANDIDATE",
		3: "NODE_ROLE_LEADER",
		4: "NODE_ROLE_LEARNER",
	}
	NodeRole_value = map[string]int32{
		"NODE_ROLE_UNSPECIFIED": 0,
		"NODE_ROLE_FOLLOWER":    1,
		"NODE_ROLE_CANDIDATE":   2,
		"NODE_ROLE_LEADER":      3,
		"NODE_ROLE_LEARNER":     4,
	}
)

func (x NodeRole) Enum() *NodeRole {
	p := new(NodeRole)
	*p = x
	return p
}

func (x NodeRole) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (NodeRole) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_common_proto_enumTypes[1].Descriptor()
}

func (NodeRole) Type() protoreflect.EnumType {
	return &file_proto_common_proto_enumTypes[1]
}

func (x NodeRole) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use NodeRole.Descriptor instead.
func (NodeRole) EnumDescriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{1}
}

// Basic definitions shared across modules
type LogId struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Term          uint64                 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"`
	Index         uint64                 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LogId) ProtoMessage() {}

func (x *LogId) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 LogId.ProtoReflect.Descriptor instead.
func (*LogId) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{0}
}

func (x *LogId) GetTerm() uint64 {
	if x != nil {
		return x.Term
	}
	return 0
}

func (x *LogId) GetIndex() uint64 {
	if x != nil {
		return x.Index
	}
	return 0
}

// Raft log entry
type Entry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Index         uint64                 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Term          uint64                 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"`
	Payload       *EntryPayload          `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Entry) ProtoMessage() {}

func (x *Entry) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 Entry.ProtoReflect.Descriptor instead.
func (*Entry) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{1}
}

func (x *Entry) GetIndex() uint64 {
	if x != nil {
		return x.Index
	}
	return 0
}

func (x *Entry) GetTerm() uint64 {
	if x != nil {
		return x.Term
	}
	return 0
}

func (x *Entry) GetPayload() *EntryPayload {
	if x != nil {
		return x.Payload
	}
	return nil
}

// Log entry payload
type EntryPayload struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Payload:
	//
	//	*EntryPayload_Noop
	//	*EntryPayload_Command
	//	*EntryPayload_Config
	Payload       isEntryPayload_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EntryPayload) ProtoMessage() {}

func (x *EntryPayload) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 EntryPayload.ProtoReflect.Descriptor instead.
func (*EntryPayload) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{2}
}

func (x *EntryPayload) GetPayload() isEntryPayload_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *EntryPayload) GetNoop() *Noop {
	if x != nil {
		if x, ok := x.Payload.(*EntryPayload_Noop); ok {
			return x.Noop
		}
	}
	return nil
}

func (x *EntryPayload) GetCommand() []byte {
	if x != nil {
		if x, ok := x.Payload.(*EntryPayload_Command); ok {
			return x.Command
		}
	}
	return nil
}

func (x *EntryPayload) GetConfig() *MembershipChange {
	if x != nil {
		if x, ok := x.Payload.(*EntryPayload_Config); ok {
			return x.Config
		}
	}
	return nil
}

type isEntryPayload_Payload interface {
	isEntryPayload_Payload()
}

type EntryPayload_Noop struct {
	Noop *Noop `protobuf:"bytes,1,opt,name=noop,proto3,oneof"` // No operation (internal to the protocol)
}

type EntryPayload_Command struct {
	Command []byte `protobuf:"bytes,2,opt,name=command,proto3,oneof"` // Business write operation
}

type EntryPayload_Config struct {
	Config *MembershipChange `protobuf:"bytes,3,opt,name=config,proto3,oneof"` // Cluster configuration change
}

func (*EntryPayload_Noop) isEntryPayload_Payload() {}

func (*EntryPayload_Command) isEntryPayload_Payload() {}

func (*EntryPayload_Config) isEntryPayload_Payload() {}

// Internal operation of the protocol
type Noop struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Noop) ProtoMessage() {}

func (x *Noop) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 Noop.ProtoReflect.Descriptor instead.
func (*Noop) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{3}
}

// Cluster configuration change
type MembershipChange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Change:
	//
	//	*MembershipChange_AddNode
	//	*MembershipChange_RemoveNode
	//	*MembershipChange_Promote
	//	*MembershipChange_BatchPromote
	//	*MembershipChange_BatchRemove
	Change        isMembershipChange_Change `protobuf_oneof:"change"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MembershipChange) ProtoMessage() {}

func (x *MembershipChange) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 MembershipChange.ProtoReflect.Descriptor instead.
func (*MembershipChange) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{4}
}

func (x *MembershipChange) GetChange() isMembershipChange_Change {
	if x != nil {
		return x.Change
	}
	return nil
}

func (x *MembershipChange) GetAddNode() *AddNode {
	if x != nil {
		if x, ok := x.Change.(*MembershipChange_AddNode); ok {
			return x.AddNode
		}
	}
	return nil
}

func (x *MembershipChange) GetRemoveNode() *RemoveNode {
	if x != nil {
		if x, ok := x.Change.(*MembershipChange_RemoveNode); ok {
			return x.RemoveNode
		}
	}
	return nil
}

func (x *MembershipChange) GetPromote() *PromoteLearner {
	if x != nil {
		if x, ok := x.Change.(*MembershipChange_Promote); ok {
			return x.Promote
		}
	}
	return nil
}

func (x *MembershipChange) GetBatchPromote() *BatchPromote {
	if x != nil {
		if x, ok := x.Change.(*MembershipChange_BatchPromote); ok {
			return x.BatchPromote
		}
	}
	return nil
}

func (x *MembershipChange) GetBatchRemove() *BatchRemove {
	if x != nil {
		if x, ok := x.Change.(*MembershipChange_BatchRemove); ok {
			return x.BatchRemove
		}
	}
	return nil
}

type isMembershipChange_Change interface {
	isMembershipChange_Change()
}

type MembershipChange_AddNode struct {
	AddNode *AddNode `protobuf:"bytes,1,opt,name=add_node,json=addNode,proto3,oneof"`
}

type MembershipChange_RemoveNode struct {
	RemoveNode *RemoveNode `protobuf:"bytes,2,opt,name=remove_node,json=removeNode,proto3,oneof"`
}

type MembershipChange_Promote struct {
	Promote *PromoteLearner `protobuf:"bytes,3,opt,name=promote,proto3,oneof"`
}

type MembershipChange_BatchPromote struct {
	BatchPromote *BatchPromote `protobuf:"bytes,4,opt,name=batch_promote,json=batchPromote,proto3,oneof"`
}

type MembershipChange_BatchRemove struct {
	BatchRemove *BatchRemove `protobuf:"bytes,5,opt,name=batch_remove,json=batchRemove,proto3,oneof"`
}

func (*MembershipChange_AddNode) isMembershipChange_Change() {}

func (*MembershipChange_RemoveNode) isMembershipChange_Change() {}

func (*MembershipChange_Promote) isMembershipChange_Change() {}

func (*MembershipChange_BatchPromote) isMembershipChange_Change() {}

func (*MembershipChange_BatchRemove) isMembershipChange_Change() {}

type AddNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NodeId        uint32                 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Status        NodeStatus             `protobuf:"varint,3,opt,name=status,proto3,enum=d_engine.common.NodeStatus" json:"status,omitempty"` // Status of the node being added (PROMOTABLE or READ_ONLY)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AddNode) ProtoMessage() {}

func (x *AddNode) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 AddNode.ProtoReflect.Descriptor instead.
func (*AddNode) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{5}
}

func (x *AddNode) GetNodeId() uint32 {
	if x != nil {
		return x.NodeId
	}
	return 0
}

func (x *AddNode) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

func (x *AddNode) GetStatus() NodeStatus {
	if x != nil {
		return x.Status
	}
	return NodeStatus_NODE_STATUS_UNSPECIFIED
}

type RemoveNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NodeId        uint32                 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RemoveNode) ProtoMessage() {}

func (x *RemoveNode) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 RemoveNode.ProtoReflect.Descriptor instead.
func (*RemoveNode) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{6}
}

func (x *RemoveNode) GetNodeId() uint32 {
	if x != nil {
		return x.NodeId
	}
	return 0
}

type PromoteLearner struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NodeId        uint32                 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Status        NodeStatus             `protobuf:"varint,2,opt,name=status,proto3,enum=d_engine.common.NodeStatus" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PromoteLearner) ProtoMessage() {}

func (x *PromoteLearner) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 PromoteLearner.ProtoReflect.Descriptor instead.
func (*PromoteLearner) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{7}
}

func (x *PromoteLearner) GetNodeId() uint32 {
	if x != nil {
		return x.NodeId
	}
	return 0
}

func (x *PromoteLearner) GetStatus() NodeStatus {
	if x != nil {
		return x.Status
	}
	return NodeStatus_NODE_STATUS_UNSPECIFIED
}

type BatchPromote struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NodeIds       []uint32               `protobuf:"varint,1,rep,packed,name=node_ids,json=nodeIds,proto3" json:"node_ids,omitempty"`
	NewStatus     NodeStatus             `protobuf:"varint,2,opt,name=new_status,json=newStatus,proto3,enum=d_engine.common.NodeStatus" json:"new_status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchPromote) ProtoMessage() {}

func (x *BatchPromote) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 BatchPromote.ProtoReflect.Descriptor instead.
func (*BatchPromote) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{8}
}

func (x *BatchPromote) GetNodeIds() []uint32 {
	if x != nil {
		return x.NodeIds
	}
	return nil
}

func (x *BatchPromote) GetNewStatus() NodeStatus {
	if x != nil {
		return x.NewStatus
	}
	return NodeStatus_NODE_STATUS_UNSPECIFIED
}

type BatchRemove struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NodeIds       []uint32               `protobuf:"varint,1,rep,packed,name=node_ids,json=nodeIds,proto3" json:"node_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchRemove) ProtoMessage() {}

func (x *BatchRemove) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 BatchRemove.ProtoReflect.Descriptor instead.
func (*BatchRemove) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{9}
}

func (x *BatchRemove) GetNodeIds() []uint32 {
	if x != nil {
		return x.NodeIds
	}
	return nil
}

type SnapshotEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SnapshotEntry) ProtoMessage() {}

func (x *SnapshotEntry) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 SnapshotEntry.ProtoReflect.Descriptor instead.
func (*SnapshotEntry) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{10}
}

func (x *SnapshotEntry) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

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

type SnapshotMeta struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	VersionHigh   uint64                 `protobuf:"varint,1,opt,name=version_high,json=versionHigh,proto3" json:"version_high,omitempty"`
	VersionLow    uint64                 `protobuf:"varint,2,opt,name=version_low,json=versionLow,proto3" json:"version_low,omitempty"`
	CreatedAtHigh uint64                 `protobuf:"varint,3,opt,name=created_at_high,json=createdAtHigh,proto3" json:"created_at_high,omitempty"`
	CreatedAtLow  uint64                 `protobuf:"varint,4,opt,name=created_at_low,json=createdAtLow,proto3" json:"created_at_low,omitempty"`
	AuthorId      uint32                 `protobuf:"varint,5,opt,name=author_id,json=authorId,proto3" json:"author_id,omitempty"`
	LastIncluded  *LogId                 `protobuf:"bytes,6,opt,name=last_included,json=lastIncluded,proto3" json:"last_included,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SnapshotMeta) ProtoMessage() {}

func (x *SnapshotMeta) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 SnapshotMeta.ProtoReflect.Descriptor instead.
func (*SnapshotMeta) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{11}
}

func (x *SnapshotMeta) GetVersionHigh() uint64 {
	if x != nil {
		return x.VersionHigh
	}
	return 0
}

func (x *SnapshotMeta) GetVersionLow() uint64 {
	if x != nil {
		return x.VersionLow
	}
	return 0
}

func (x *SnapshotMeta) GetCreatedAtHigh() uint64 {
	if x != nil {
		return x.CreatedAtHigh
	}
	return 0
}

func (x *SnapshotMeta) GetCreatedAtLow() uint64 {
	if x != nil {
		return x.CreatedAtLow
	}
	return 0
}

func (x *SnapshotMeta) GetAuthorId() uint32 {
	if x != nil {
		return x.AuthorId
	}
	return 0
}

func (x *SnapshotMeta) GetLastIncluded() *LogId {
	if x != nil {
		return x.LastIncluded
	}
	return nil
}

type Snapshot struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Meta          *SnapshotMeta          `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"`
	Data          []*SnapshotEntry       `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Snapshot) ProtoMessage() {}

func (x *Snapshot) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 Snapshot.ProtoReflect.Descriptor instead.
func (*Snapshot) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{12}
}

func (x *Snapshot) GetMeta() *SnapshotMeta {
	if x != nil {
		return x.Meta
	}
	return nil
}

func (x *Snapshot) GetData() []*SnapshotEntry {
	if x != nil {
		return x.Data
	}
	return nil
}

// Leader election information
// Used at: Application layer (internal Raft protocol notifications)
// Purpose: Notify applications about leader changes via watch channel
// Fields: Minimal - only what Raft protocol needs
type LeaderInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	LeaderId      uint32                 `protobuf:"varint,1,opt,name=leader_id,json=leaderId,proto3" json:"leader_id,omitempty"` // Current leader node ID
	Term          uint64                 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"`                         // Current Raft term
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LeaderInfo) ProtoMessage() {}

func (x *LeaderInfo) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 LeaderInfo.ProtoReflect.Descriptor instead.
func (*LeaderInfo) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{13}
}

func (x *LeaderInfo) GetLeaderId() uint32 {
	if x != nil {
		return x.LeaderId
	}
	return 0
}

func (x *LeaderInfo) GetTerm() uint64 {
	if x != nil {
		return x.Term
	}
	return 0
}

// Leader hint for client redirection
// Used at: Network layer (gRPC error responses)
// Purpose: Help clients redirect requests to the current leader
// Fields: Includes network address for immediate retry
type LeaderHint struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	LeaderId      uint32                 `protobuf:"varint,1,opt,name=leader_id,json=leaderId,proto3" json:"leader_id,omitempty"` // Current leader node ID
	Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`                    // Leader's network address (e.g., "127.0.0.1:5001")
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LeaderHint) ProtoMessage() {}

func (x *LeaderHint) ProtoReflect() protoreflect.Message {
	mi := &file_proto_common_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 LeaderHint.ProtoReflect.Descriptor instead.
func (*LeaderHint) Descriptor() ([]byte, []int) {
	return file_proto_common_proto_rawDescGZIP(), []int{14}
}

func (x *LeaderHint) GetLeaderId() uint32 {
	if x != nil {
		return x.LeaderId
	}
	return 0
}

func (x *LeaderHint) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

var File_proto_common_proto protoreflect.FileDescriptor

const file_proto_common_proto_rawDesc = "" +
	"\n" +
	"\x12proto/common.proto\x12\x0fd_engine.common\"1\n" +
	"\x05LogId\x12\x12\n" +
	"\x04term\x18\x01 \x01(\x04R\x04term\x12\x14\n" +
	"\x05index\x18\x02 \x01(\x04R\x05index\"j\n" +
	"\x05Entry\x12\x14\n" +
	"\x05index\x18\x01 \x01(\x04R\x05index\x12\x12\n" +
	"\x04term\x18\x02 \x01(\x04R\x04term\x127\n" +
	"\apayload\x18\x03 \x01(\v2\x1d.d_engine.common.EntryPayloadR\apayload\"\x9f\x01\n" +
	"\fEntryPayload\x12+\n" +
	"\x04noop\x18\x01 \x01(\v2\x15.d_engine.common.NoopH\x00R\x04noop\x12\x1a\n" +
	"\acommand\x18\x02 \x01(\fH\x00R\acommand\x12;\n" +
	"\x06config\x18\x03 \x01(\v2!.d_engine.common.MembershipChangeH\x00R\x06configB\t\n" +
	"\apayload\"\x06\n" +
	"\x04Noop\"\xd9\x02\n" +
	"\x10MembershipChange\x125\n" +
	"\badd_node\x18\x01 \x01(\v2\x18.d_engine.common.AddNodeH\x00R\aaddNode\x12>\n" +
	"\vremove_node\x18\x02 \x01(\v2\x1b.d_engine.common.RemoveNodeH\x00R\n" +
	"removeNode\x12;\n" +
	"\apromote\x18\x03 \x01(\v2\x1f.d_engine.common.PromoteLearnerH\x00R\apromote\x12D\n" +
	"\rbatch_promote\x18\x04 \x01(\v2\x1d.d_engine.common.BatchPromoteH\x00R\fbatchPromote\x12A\n" +
	"\fbatch_remove\x18\x05 \x01(\v2\x1c.d_engine.common.BatchRemoveH\x00R\vbatchRemoveB\b\n" +
	"\x06change\"q\n" +
	"\aAddNode\x12\x17\n" +
	"\anode_id\x18\x01 \x01(\rR\x06nodeId\x12\x18\n" +
	"\aaddress\x18\x02 \x01(\tR\aaddress\x123\n" +
	"\x06status\x18\x03 \x01(\x0e2\x1b.d_engine.common.NodeStatusR\x06status\"%\n" +
	"\n" +
	"RemoveNode\x12\x17\n" +
	"\anode_id\x18\x01 \x01(\rR\x06nodeId\"^\n" +
	"\x0ePromoteLearner\x12\x17\n" +
	"\anode_id\x18\x01 \x01(\rR\x06nodeId\x123\n" +
	"\x06status\x18\x02 \x01(\x0e2\x1b.d_engine.common.NodeStatusR\x06status\"e\n" +
	"\fBatchPromote\x12\x19\n" +
	"\bnode_ids\x18\x01 \x03(\rR\anodeIds\x12:\n" +
	"\n" +
	"new_status\x18\x02 \x01(\x0e2\x1b.d_engine.common.NodeStatusR\tnewStatus\"(\n" +
	"\vBatchRemove\x12\x19\n" +
	"\bnode_ids\x18\x01 \x03(\rR\anodeIds\"7\n" +
	"\rSnapshotEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\fR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\"\xfa\x01\n" +
	"\fSnapshotMeta\x12!\n" +
	"\fversion_high\x18\x01 \x01(\x04R\vversionHigh\x12\x1f\n" +
	"\vversion_low\x18\x02 \x01(\x04R\n" +
	"versionLow\x12&\n" +
	"\x0fcreated_at_high\x18\x03 \x01(\x04R\rcreatedAtHigh\x12$\n" +
	"\x0ecreated_at_low\x18\x04 \x01(\x04R\fcreatedAtLow\x12\x1b\n" +
	"\tauthor_id\x18\x05 \x01(\rR\bauthorId\x12;\n" +
	"\rlast_included\x18\x06 \x01(\v2\x16.d_engine.common.LogIdR\flastIncluded\"q\n" +
	"\bSnapshot\x121\n" +
	"\x04meta\x18\x01 \x01(\v2\x1d.d_engine.common.SnapshotMetaR\x04meta\x122\n" +
	"\x04data\x18\x02 \x03(\v2\x1e.d_engine.common.SnapshotEntryR\x04data\"=\n" +
	"\n" +
	"LeaderInfo\x12\x1b\n" +
	"\tleader_id\x18\x01 \x01(\rR\bleaderId\x12\x12\n" +
	"\x04term\x18\x02 \x01(\x04R\x04term\"C\n" +
	"\n" +
	"LeaderHint\x12\x1b\n" +
	"\tleader_id\x18\x01 \x01(\rR\bleaderId\x12\x18\n" +
	"\aaddress\x18\x02 \x01(\tR\aaddress*x\n" +
	"\n" +
	"NodeStatus\x12\x1b\n" +
	"\x17NODE_STATUS_UNSPECIFIED\x10\x00\x12\x1a\n" +
	"\x16NODE_STATUS_PROMOTABLE\x10\x01\x12\x19\n" +
	"\x15NODE_STATUS_READ_ONLY\x10\x02\x12\x16\n" +
	"\x12NODE_STATUS_ACTIVE\x10\x03*\x83\x01\n" +
	"\bNodeRole\x12\x19\n" +
	"\x15NODE_ROLE_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12NODE_ROLE_FOLLOWER\x10\x01\x12\x17\n" +
	"\x13NODE_ROLE_CANDIDATE\x10\x02\x12\x14\n" +
	"\x10NODE_ROLE_LEADER\x10\x03\x12\x15\n" +
	"\x11NODE_ROLE_LEARNER\x10\x04B,Z*github.com/deventlab/d-engine/proto/commonb\x06proto3"

var (
	file_proto_common_proto_rawDescOnce sync.Once
	file_proto_common_proto_rawDescData []byte
)

func file_proto_common_proto_rawDescGZIP() []byte {
	file_proto_common_proto_rawDescOnce.Do(func() {
		file_proto_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto_common_proto_rawDesc), len(file_proto_common_proto_rawDesc)))
	})
	return file_proto_common_proto_rawDescData
}

var file_proto_common_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_proto_common_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
var file_proto_common_proto_goTypes = []any{
	(NodeStatus)(0),          // 0: d_engine.common.NodeStatus
	(NodeRole)(0),            // 1: d_engine.common.NodeRole
	(*LogId)(nil),            // 2: d_engine.common.LogId
	(*Entry)(nil),            // 3: d_engine.common.Entry
	(*EntryPayload)(nil),     // 4: d_engine.common.EntryPayload
	(*Noop)(nil),             // 5: d_engine.common.Noop
	(*MembershipChange)(nil), // 6: d_engine.common.MembershipChange
	(*AddNode)(nil),          // 7: d_engine.common.AddNode
	(*RemoveNode)(nil),       // 8: d_engine.common.RemoveNode
	(*PromoteLearner)(nil),   // 9: d_engine.common.PromoteLearner
	(*BatchPromote)(nil),     // 10: d_engine.common.BatchPromote
	(*BatchRemove)(nil),      // 11: d_engine.common.BatchRemove
	(*SnapshotEntry)(nil),    // 12: d_engine.common.SnapshotEntry
	(*SnapshotMeta)(nil),     // 13: d_engine.common.SnapshotMeta
	(*Snapshot)(nil),         // 14: d_engine.common.Snapshot
	(*LeaderInfo)(nil),       // 15: d_engine.common.LeaderInfo
	(*LeaderHint)(nil),       // 16: d_engine.common.LeaderHint
}
var file_proto_common_proto_depIdxs = []int32{
	4,  // 0: d_engine.common.Entry.payload:type_name -> d_engine.common.EntryPayload
	5,  // 1: d_engine.common.EntryPayload.noop:type_name -> d_engine.common.Noop
	6,  // 2: d_engine.common.EntryPayload.config:type_name -> d_engine.common.MembershipChange
	7,  // 3: d_engine.common.MembershipChange.add_node:type_name -> d_engine.common.AddNode
	8,  // 4: d_engine.common.MembershipChange.remove_node:type_name -> d_engine.common.RemoveNode
	9,  // 5: d_engine.common.MembershipChange.promote:type_name -> d_engine.common.PromoteLearner
	10, // 6: d_engine.common.MembershipChange.batch_promote:type_name -> d_engine.common.BatchPromote
	11, // 7: d_engine.common.MembershipChange.batch_remove:type_name -> d_engine.common.BatchRemove
	0,  // 8: d_engine.common.AddNode.status:type_name -> d_engine.common.NodeStatus
	0,  // 9: d_engine.common.PromoteLearner.status:type_name -> d_engine.common.NodeStatus
	0,  // 10: d_engine.common.BatchPromote.new_status:type_name -> d_engine.common.NodeStatus
	2,  // 11: d_engine.common.SnapshotMeta.last_included:type_name -> d_engine.common.LogId
	13, // 12: d_engine.common.Snapshot.meta:type_name -> d_engine.common.SnapshotMeta
	12, // 13: d_engine.common.Snapshot.data:type_name -> d_engine.common.SnapshotEntry
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_proto_common_proto_init() }
func file_proto_common_proto_init() {
	if File_proto_common_proto != nil {
		return
	}
	file_proto_common_proto_msgTypes[2].OneofWrappers = []any{
		(*EntryPayload_Noop)(nil),
		(*EntryPayload_Command)(nil),
		(*EntryPayload_Config)(nil),
	}
	file_proto_common_proto_msgTypes[4].OneofWrappers = []any{
		(*MembershipChange_AddNode)(nil),
		(*MembershipChange_RemoveNode)(nil),
		(*MembershipChange_Promote)(nil),
		(*MembershipChange_BatchPromote)(nil),
		(*MembershipChange_BatchRemove)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_common_proto_rawDesc), len(file_proto_common_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   15,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_proto_common_proto_goTypes,
		DependencyIndexes: file_proto_common_proto_depIdxs,
		EnumInfos:         file_proto_common_proto_enumTypes,
		MessageInfos:      file_proto_common_proto_msgTypes,
	}.Build()
	File_proto_common_proto = out.File
	file_proto_common_proto_goTypes = nil
	file_proto_common_proto_depIdxs = nil
}